diff --git a/synchronizer/batches_test.go b/synchronizer/batches_test.go
index a8c1580..7badb78 100644
--- a/synchronizer/batches_test.go
+++ b/synchronizer/batches_test.go
@@ -272,12 +272,8 @@ func TestBatchSynchronizer_HandleEvent(t *testing.T) {
 		getTxArgs    []interface{}
 		getTxReturns []interface{}
 		// db mock
-		beginStateTransactionArgs       []interface{}
-		beginStateTransactionReturns    []interface{}
 		storeUnresolvedBatchKeysArgs    []interface{}
 		storeUnresolvedBatchKeysReturns []interface{}
-		commitReturns                   []interface{}
-		rollbackArgs                    []interface{}
 
 		isErrorExpected bool
 	}
@@ -319,7 +315,6 @@ func TestBatchSynchronizer_HandleEvent(t *testing.T) {
 
 	testFn := func(t *testing.T, config testConfig) {
 		dbMock := mocks.NewDB(t)
-		txMock := mocks.NewTx(t)
 		ethermanMock := mocks.NewEtherman(t)
 
 		if config.getTxArgs != nil && config.getTxReturns != nil {
@@ -327,32 +322,11 @@ func TestBatchSynchronizer_HandleEvent(t *testing.T) {
 				config.getTxReturns...).Once()
 		}
 
-		if config.beginStateTransactionArgs != nil {
-			var returnArgs []interface{}
-			if config.beginStateTransactionReturns != nil {
-				returnArgs = config.beginStateTransactionReturns
-			} else {
-				returnArgs = append(returnArgs, txMock, nil)
-			}
-
-			dbMock.On("BeginStateTransaction", config.beginStateTransactionArgs...).Return(
-				returnArgs...).Once()
-		}
-
 		if config.storeUnresolvedBatchKeysArgs != nil && config.storeUnresolvedBatchKeysReturns != nil {
 			dbMock.On("StoreUnresolvedBatchKeys", config.storeUnresolvedBatchKeysArgs...).Return(
 				config.storeUnresolvedBatchKeysReturns...).Once()
 		}
 
-		if config.commitReturns != nil {
-			txMock.On("Commit", mock.Anything).Return(
-				config.commitReturns...).Once()
-		}
-
-		if config.rollbackArgs != nil {
-			txMock.On("Rollback", config.rollbackArgs...).Return(nil).Once()
-		}
-
 		batchSynronizer := &BatchSynchronizer{
 			db:     dbMock,
 			client: ethermanMock,
@@ -366,7 +340,6 @@ func TestBatchSynchronizer_HandleEvent(t *testing.T) {
 		}
 
 		dbMock.AssertExpectations(t)
-		txMock.AssertExpectations(t)
 		ethermanMock.AssertExpectations(t)
 	}
 
@@ -422,9 +395,8 @@ func TestBatchSynchronizer_HandleEvent(t *testing.T) {
 			})
 
 		testFn(t, testConfig{
-			getTxArgs:                 []interface{}{mock.Anything, event.Raw.TxHash},
-			getTxReturns:              []interface{}{localTx, true, nil},
-			beginStateTransactionArgs: []interface{}{mock.Anything},
+			getTxArgs:    []interface{}{mock.Anything, event.Raw.TxHash},
+			getTxReturns: []interface{}{localTx, true, nil},
 			storeUnresolvedBatchKeysArgs: []interface{}{
 				mock.Anything,
 				[]types.BatchKey{{
@@ -434,7 +406,6 @@ func TestBatchSynchronizer_HandleEvent(t *testing.T) {
 				mock.Anything,
 			},
 			storeUnresolvedBatchKeysReturns: []interface{}{nil},
-			commitReturns:                   []interface{}{nil},
 			isErrorExpected:                 false,
 		})
 	})
@@ -443,9 +414,8 @@ func TestBatchSynchronizer_HandleEvent(t *testing.T) {
 		t.Parallel()
 
 		testFn(t, testConfig{
-			getTxArgs:                 []interface{}{mock.Anything, event.Raw.TxHash},
-			getTxReturns:              []interface{}{tx, true, nil},
-			beginStateTransactionArgs: []interface{}{mock.Anything},
+			getTxArgs:    []interface{}{mock.Anything, event.Raw.TxHash},
+			getTxReturns: []interface{}{tx, true, nil},
 			storeUnresolvedBatchKeysArgs: []interface{}{
 				mock.Anything,
 				[]types.BatchKey{{
@@ -455,23 +425,10 @@ func TestBatchSynchronizer_HandleEvent(t *testing.T) {
 				mock.Anything,
 			},
 			storeUnresolvedBatchKeysReturns: []interface{}{nil},
-			commitReturns:                   []interface{}{nil},
 			isErrorExpected:                 false,
 		})
 	})
 
-	t.Run("doesn't have batch in storage - begin state transaction fails", func(t *testing.T) {
-		t.Parallel()
-
-		testFn(t, testConfig{
-			isErrorExpected:              true,
-			beginStateTransactionArgs:    []interface{}{mock.Anything},
-			beginStateTransactionReturns: []interface{}{nil, errors.New("error")},
-			getTxArgs:                    []interface{}{mock.Anything, event.Raw.TxHash},
-			getTxReturns:                 []interface{}{tx, true, nil},
-		})
-	})
-
 	t.Run("doesn't have batch in storage - store fails", func(t *testing.T) {
 		t.Parallel()
 
@@ -486,29 +443,6 @@ func TestBatchSynchronizer_HandleEvent(t *testing.T) {
 				mock.Anything,
 			},
 			storeUnresolvedBatchKeysReturns: []interface{}{errors.New("error")},
-			beginStateTransactionArgs:       []interface{}{mock.Anything},
-			rollbackArgs:                    []interface{}{mock.Anything},
-			getTxArgs:                       []interface{}{mock.Anything, event.Raw.TxHash},
-			getTxReturns:                    []interface{}{tx, true, nil},
-		})
-	})
-
-	t.Run("doesn't have batch in storage - commit fails", func(t *testing.T) {
-		t.Parallel()
-
-		testFn(t, testConfig{
-			isErrorExpected:           true,
-			beginStateTransactionArgs: []interface{}{mock.Anything},
-			storeUnresolvedBatchKeysArgs: []interface{}{
-				mock.Anything,
-				[]types.BatchKey{{
-					Number: 10,
-					Hash:   txHash,
-				}},
-				mock.Anything,
-			},
-			storeUnresolvedBatchKeysReturns: []interface{}{nil},
-			commitReturns:                   []interface{}{errors.New("error")},
 			getTxArgs:                       []interface{}{mock.Anything, event.Raw.TxHash},
 			getTxReturns:                    []interface{}{tx, true, nil},
 		})
@@ -520,22 +454,14 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 
 	type testConfig struct {
 		// db mock
-		getUnresolvedBatchKeysArgs         []interface{}
-		getUnresolvedBatchKeysReturns      []interface{}
-		existsArgs                         []interface{}
-		existsReturns                      []interface{}
-		storeBeginStateTransactionArgs     []interface{}
-		storeBeginStateTransactionReturns  []interface{}
-		storeOffChainDataArgs              []interface{}
-		storeOffChainDataReturns           []interface{}
-		storeCommitReturns                 []interface{}
-		storeRollbackArgs                  []interface{}
-		deleteBeginStateTransactionArgs    []interface{}
-		deleteBeginStateTransactionReturns []interface{}
-		deleteUnresolvedBatchKeysArgs      []interface{}
-		deleteUnresolvedBatchKeysReturns   []interface{}
-		deleteCommitReturns                []interface{}
-		deleteRollbackArgs                 []interface{}
+		getUnresolvedBatchKeysArgs       []interface{}
+		getUnresolvedBatchKeysReturns    []interface{}
+		existsArgs                       []interface{}
+		existsReturns                    []interface{}
+		storeOffChainDataArgs            []interface{}
+		storeOffChainDataReturns         []interface{}
+		deleteUnresolvedBatchKeysArgs    []interface{}
+		deleteUnresolvedBatchKeysReturns []interface{}
 		// sequencer mocks
 		getSequenceBatchArgs    []interface{}
 		getSequenceBatchReturns []interface{}
@@ -548,8 +474,6 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 
 	testFn := func(t *testing.T, config testConfig) {
 		dbMock := mocks.NewDB(t)
-		storeTxMock := mocks.NewTx(t)
-		deleteTxMock := mocks.NewTx(t)
 		ethermanMock := mocks.NewEtherman(t)
 		sequencerMock := mocks.NewSequencerTracker(t)
 
@@ -563,58 +487,16 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 				config.existsReturns...).Once()
 		}
 
-		if config.storeBeginStateTransactionArgs != nil {
-			var returnArgs []interface{}
-			if config.storeBeginStateTransactionReturns != nil {
-				returnArgs = config.storeBeginStateTransactionArgs
-			} else {
-				returnArgs = append(returnArgs, storeTxMock, nil)
-			}
-
-			dbMock.On("BeginStateTransaction", config.storeBeginStateTransactionArgs...).Return(
-				returnArgs...).Once()
-		}
-
 		if config.storeOffChainDataArgs != nil && config.storeOffChainDataReturns != nil {
 			dbMock.On("StoreOffChainData", config.storeOffChainDataArgs...).Return(
 				config.storeOffChainDataReturns...).Once()
 		}
 
-		if config.storeCommitReturns != nil {
-			storeTxMock.On("Commit", mock.Anything).Return(
-				config.storeCommitReturns...).Once()
-		}
-
-		if config.storeRollbackArgs != nil {
-			storeTxMock.On("Rollback", config.storeRollbackArgs...).Return(nil).Once()
-		}
-
-		if config.deleteBeginStateTransactionArgs != nil {
-			var returnArgs []interface{}
-			if config.deleteBeginStateTransactionReturns != nil {
-				returnArgs = config.deleteBeginStateTransactionArgs
-			} else {
-				returnArgs = append(returnArgs, deleteTxMock, nil)
-			}
-
-			dbMock.On("BeginStateTransaction", config.deleteBeginStateTransactionArgs...).Return(
-				returnArgs...).Once()
-		}
-
 		if config.deleteUnresolvedBatchKeysArgs != nil && config.deleteUnresolvedBatchKeysReturns != nil {
 			dbMock.On("DeleteUnresolvedBatchKeys", config.deleteUnresolvedBatchKeysArgs...).Return(
 				config.deleteUnresolvedBatchKeysReturns...).Once()
 		}
 
-		if config.deleteCommitReturns != nil {
-			deleteTxMock.On("Commit", mock.Anything).Return(
-				config.deleteCommitReturns...).Once()
-		}
-
-		if config.deleteRollbackArgs != nil {
-			deleteTxMock.On("Rollback", config.deleteRollbackArgs...).Return(nil).Once()
-		}
-
 		if config.getSequenceBatchArgs != nil && config.getSequenceBatchReturns != nil {
 			sequencerMock.On("GetSequenceBatch", config.getSequenceBatchArgs...).Return(
 				config.getSequenceBatchReturns...).Once()
@@ -634,8 +516,6 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 		}
 
 		dbMock.AssertExpectations(t)
-		storeTxMock.AssertExpectations(t)
-		deleteTxMock.AssertExpectations(t)
 		ethermanMock.AssertExpectations(t)
 		sequencerMock.AssertExpectations(t)
 	}
@@ -672,9 +552,8 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 				}},
 				nil,
 			},
-			existsArgs:                      []interface{}{mock.Anything, txHash},
-			existsReturns:                   []interface{}{true},
-			deleteBeginStateTransactionArgs: []interface{}{mock.Anything},
+			existsArgs:    []interface{}{mock.Anything, txHash},
+			existsReturns: []interface{}{true},
 			deleteUnresolvedBatchKeysArgs: []interface{}{mock.Anything,
 				[]types.BatchKey{{
 					Number: 10,
@@ -683,7 +562,6 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 				mock.Anything,
 			},
 			deleteUnresolvedBatchKeysReturns: []interface{}{nil},
-			deleteCommitReturns:              []interface{}{nil},
 			isErrorExpected:                  false,
 		})
 	})
@@ -700,9 +578,8 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 				}},
 				nil,
 			},
-			existsArgs:                     []interface{}{mock.Anything, txHash},
-			existsReturns:                  []interface{}{false},
-			storeBeginStateTransactionArgs: []interface{}{mock.Anything},
+			existsArgs:    []interface{}{mock.Anything, txHash},
+			existsReturns: []interface{}{false},
 			storeOffChainDataArgs: []interface{}{mock.Anything,
 				[]types.OffChainData{{
 					Key:   txHash,
@@ -710,9 +587,7 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 				}},
 				mock.Anything,
 			},
-			storeOffChainDataReturns:        []interface{}{nil},
-			storeCommitReturns:              []interface{}{nil},
-			deleteBeginStateTransactionArgs: []interface{}{mock.Anything},
+			storeOffChainDataReturns: []interface{}{nil},
 			deleteUnresolvedBatchKeysArgs: []interface{}{mock.Anything,
 				[]types.BatchKey{{
 					Number: 10,
@@ -721,7 +596,6 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 				mock.Anything,
 			},
 			deleteUnresolvedBatchKeysReturns: []interface{}{nil},
-			deleteCommitReturns:              []interface{}{nil},
 			getSequenceBatchArgs:             []interface{}{uint64(10)},
 			getSequenceBatchReturns: []interface{}{&sequencer.SeqBatch{
 				Number:      types.ArgUint64(10),
@@ -775,23 +649,6 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 		})
 	})
 
-	t.Run("doesn't have batch in storage - begin state transaction fails", func(t *testing.T) {
-		t.Parallel()
-
-		testFn(testConfig{
-			isErrorExpected:              true,
-			beginStateTransactionArgs:    []interface{}{mock.Anything},
-			beginStateTransactionReturns: []interface{}{nil, errors.New("error")},
-			getTxArgs:                    []interface{}{mock.Anything, event.Raw.TxHash},
-			getTxReturns:                 []interface{}{tx, true, nil},
-			getSequenceBatchArgs:         []interface{}{event.NumBatch},
-			getSequenceBatchReturns: []interface{}{&sequencer.SeqBatch{
-				Number:      types.ArgUint64(event.NumBatch),
-				BatchL2Data: types.ArgBytes(batchL2Data),
-			}, nil},
-		})
-	})
-
 	t.Run("doesn't have batch in storage - store fails", func(t *testing.T) {
 		t.Parallel()
 
@@ -816,30 +673,6 @@ func TestBatchSynchronizer_HandleUnresolvedBatches(t *testing.T) {
 			}, nil},
 		})
 	})
-
-	t.Run("doesn't have batch in storage - commit fails", func(t *testing.T) {
-		t.Parallel()
-
-		testFn(testConfig{
-			isErrorExpected:           true,
-			beginStateTransactionArgs: []interface{}{mock.Anything},
-			storeUnresolvedBatchKeysArgs: []interface{}{mock.Anything,
-				[]types.BatchKey{{
-					Number: 1,
-					Hash:   txHash,
-				}},
-				mock.Anything,
-			},
-			storeUnresolvedBatchKeysReturns: []interface{}{nil},
-			commitReturns:                   []interface{}{errors.New("error")},
-			getSequenceBatchArgs:            []interface{}{event.NumBatch},
-			getSequenceBatchReturns: []interface{}{&sequencer.SeqBatch{
-				Number:      types.ArgUint64(event.NumBatch),
-				BatchL2Data: types.ArgBytes(batchL2Data),
-			}, nil},
-			getTxArgs:    []interface{}{mock.Anything, event.Raw.TxHash},
-			getTxReturns: []interface{}{tx, true, nil},
-		})
 	})*/
 }
 
diff --git a/synchronizer/init_test.go b/synchronizer/init_test.go
index 266f65a..9f56da5 100644
--- a/synchronizer/init_test.go
+++ b/synchronizer/init_test.go
@@ -23,11 +23,8 @@ func Test_InitStartBlock(t *testing.T) {
 		// store mocks
 		getLastProcessedBlockArgs      []interface{}
 		getLastProcessedBlockReturns   []interface{}
-		beginStateTransactionArgs      []interface{}
-		beginStateTransactionReturns   []interface{}
 		storeLastProcessedBlockArgs    []interface{}
 		storeLastProcessedBlockReturns []interface{}
-		commitReturns                  []interface{}
 		// eth client mocks
 		headerByNumberArgs    []interface{}
 		headerByNumberReturns []interface{}
@@ -49,7 +46,6 @@ func Test_InitStartBlock(t *testing.T) {
 
 	testFn := func(t *testing.T, config testConfig) {
 		dbMock := mocks.NewDB(t)
-		txMock := mocks.NewTx(t)
 		emMock := mocks.NewEtherman(t)
 
 		if config.getLastProcessedBlockArgs != nil && config.getLastProcessedBlockReturns != nil {
@@ -62,22 +58,6 @@ func Test_InitStartBlock(t *testing.T) {
 				config.storeLastProcessedBlockReturns...).Once()
 		}
 
-		if config.commitReturns != nil {
-			txMock.On("Commit", mock.Anything).Return(config.commitReturns...).Once()
-		}
-
-		if config.beginStateTransactionArgs != nil {
-			var returnArgs []interface{}
-			if config.beginStateTransactionReturns != nil {
-				returnArgs = config.beginStateTransactionReturns
-			} else {
-				returnArgs = append(returnArgs, txMock, nil)
-			}
-
-			dbMock.On("BeginStateTransaction", config.beginStateTransactionArgs...).Return(
-				returnArgs...).Once()
-		}
-
 		if config.headerByNumberArgs != nil && config.headerByNumberReturns != nil {
 			emMock.On("HeaderByNumber", config.headerByNumberArgs...).Return(
 				config.headerByNumberReturns...).Once()
@@ -104,7 +84,6 @@ func Test_InitStartBlock(t *testing.T) {
 		}
 
 		dbMock.AssertExpectations(t)
-		txMock.AssertExpectations(t)
 	}
 
 	t.Run("GetLastProcessedBlock returns an error", func(t *testing.T) {
@@ -139,29 +118,12 @@ func Test_InitStartBlock(t *testing.T) {
 		})
 	})
 
-	t.Run("BeginStateTransaction fails", func(t *testing.T) {
-		t.Parallel()
-
-		testFn(t, testConfig{
-			getLastProcessedBlockArgs:    []interface{}{mock.Anything, L1SyncTask},
-			getLastProcessedBlockReturns: []interface{}{uint64(0), nil},
-			beginStateTransactionArgs:    []interface{}{mock.Anything},
-			beginStateTransactionReturns: []interface{}{nil, errors.New("error")},
-			headerByNumberArgs:           []interface{}{mock.Anything, mock.Anything},
-			headerByNumberReturns: []interface{}{ethTypes.NewBlockWithHeader(&ethTypes.Header{
-				Number: big.NewInt(0),
-			}).Header(), nil},
-			isErrorExpected: true,
-		})
-	})
-
 	t.Run("Store off-chain data fails", func(t *testing.T) {
 		t.Parallel()
 
 		testFn(t, testConfig{
 			getLastProcessedBlockArgs:      []interface{}{mock.Anything, L1SyncTask},
 			getLastProcessedBlockReturns:   []interface{}{uint64(0), nil},
-			beginStateTransactionArgs:      []interface{}{mock.Anything},
 			storeLastProcessedBlockArgs:    []interface{}{mock.Anything, L1SyncTask, uint64(0), mock.Anything},
 			storeLastProcessedBlockReturns: []interface{}{errors.New("error")},
 			headerByNumberArgs:             []interface{}{mock.Anything, mock.Anything},
@@ -172,35 +134,14 @@ func Test_InitStartBlock(t *testing.T) {
 		})
 	})
 
-	t.Run("Commit fails", func(t *testing.T) {
-		t.Parallel()
-
-		testFn(t, testConfig{
-			headerByNumberArgs: []interface{}{mock.Anything, mock.Anything},
-			headerByNumberReturns: []interface{}{ethTypes.NewBlockWithHeader(&ethTypes.Header{
-				Number: big.NewInt(0),
-			}).Header(), nil},
-			getLastProcessedBlockArgs:      []interface{}{mock.Anything, L1SyncTask},
-			getLastProcessedBlockReturns:   []interface{}{uint64(0), nil},
-			storeLastProcessedBlockArgs:    []interface{}{mock.Anything, L1SyncTask, uint64(0), mock.Anything},
-			storeLastProcessedBlockReturns: []interface{}{nil},
-			beginStateTransactionArgs:      []interface{}{mock.Anything},
-			commitReturns:                  []interface{}{errors.New("error")},
-
-			isErrorExpected: true,
-		})
-	})
-
 	t.Run("Successful init", func(t *testing.T) {
 		t.Parallel()
 
 		testFn(t, testConfig{
 			getLastProcessedBlockArgs:      []interface{}{mock.Anything, L1SyncTask},
 			getLastProcessedBlockReturns:   []interface{}{uint64(0), nil},
-			beginStateTransactionArgs:      []interface{}{mock.Anything},
 			storeLastProcessedBlockArgs:    []interface{}{mock.Anything, L1SyncTask, uint64(2), mock.Anything},
 			storeLastProcessedBlockReturns: []interface{}{nil},
-			commitReturns:                  []interface{}{nil},
 			headerByNumberArgs:             []interface{}{mock.Anything, mock.Anything},
 			headerByNumberReturns: []interface{}{ethTypes.NewBlockWithHeader(&ethTypes.Header{
 				Number: big.NewInt(3),
diff --git a/synchronizer/store_test.go b/synchronizer/store_test.go
index d9e2314..34b1551 100644
--- a/synchronizer/store_test.go
+++ b/synchronizer/store_test.go
@@ -70,29 +70,12 @@ func Test_setStartBlock(t *testing.T) {
 		block   uint64
 		wantErr bool
 	}{
-		{
-			name: "BeginStateTransaction returns error",
-			db: func(t *testing.T) db.DB {
-				mockDB := mocks.NewDB(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).
-					Return(nil, testError)
-
-				return mockDB
-			},
-			block:   1,
-			wantErr: true,
-		},
 		{
 			name: "StoreLastProcessedBlock returns error",
 			db: func(t *testing.T) db.DB {
 				mockDB := mocks.NewDB(t)
 
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("StoreLastProcessedBlock", mock.Anything, "L1", uint64(2), mockTx).
+				mockDB.On("StoreLastProcessedBlock", mock.Anything, "L1", uint64(2)).
 					Return(testError)
 
 				return mockDB
@@ -100,39 +83,12 @@ func Test_setStartBlock(t *testing.T) {
 			block:   2,
 			wantErr: true,
 		},
-		{
-			name: "Commit returns error",
-			db: func(t *testing.T) db.DB {
-				mockDB := mocks.NewDB(t)
-
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("StoreLastProcessedBlock", mock.Anything, "L1", uint64(3), mockTx).
-					Return(nil)
-
-				mockTx.On("Commit").
-					Return(testError)
-
-				return mockDB
-			},
-			block:   3,
-			wantErr: true,
-		},
 		{
 			name: "all good",
 			db: func(t *testing.T) db.DB {
 				mockDB := mocks.NewDB(t)
 
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("StoreLastProcessedBlock", mock.Anything, "L1", uint64(4), mockTx).
-					Return(nil)
-
-				mockTx.On("Commit").
+				mockDB.On("StoreLastProcessedBlock", mock.Anything, "L1", uint64(4)).
 					Return(nil)
 
 				return mockDB
@@ -212,48 +168,12 @@ func Test_storeUnresolvedBatchKeys(t *testing.T) {
 		keys    []types.BatchKey
 		wantErr bool
 	}{
-		{
-			name: "BeginStateTransaction returns error",
-			db: func(t *testing.T) db.DB {
-				mockDB := mocks.NewDB(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(nil, testError)
-
-				return mockDB
-			},
-			keys:    testData,
-			wantErr: true,
-		},
 		{
 			name: "StoreUnresolvedBatchKeys returns error",
 			db: func(t *testing.T) db.DB {
 				mockDB := mocks.NewDB(t)
 
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("StoreUnresolvedBatchKeys", mock.Anything, testData, mockTx).Return(testError)
-
-				mockTx.On("Rollback").Return(nil)
-
-				return mockDB
-			},
-			keys:    testData,
-			wantErr: true,
-		},
-		{
-			name: "Commit returns error",
-			db: func(t *testing.T) db.DB {
-				mockDB := mocks.NewDB(t)
-
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("StoreUnresolvedBatchKeys", mock.Anything, testData, mockTx).Return(nil)
-
-				mockTx.On("Commit").Return(testError)
+				mockDB.On("StoreUnresolvedBatchKeys", mock.Anything, testData).Return(testError)
 
 				return mockDB
 			},
@@ -265,13 +185,7 @@ func Test_storeUnresolvedBatchKeys(t *testing.T) {
 			db: func(t *testing.T) db.DB {
 				mockDB := mocks.NewDB(t)
 
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("StoreUnresolvedBatchKeys", mock.Anything, testData, mockTx).Return(nil)
-
-				mockTx.On("Commit").Return(nil)
+				mockDB.On("StoreUnresolvedBatchKeys", mock.Anything, testData).Return(nil)
 
 				return mockDB
 			},
@@ -358,49 +272,12 @@ func Test_deleteUnresolvedBatchKeys(t *testing.T) {
 		db      func(t *testing.T) db.DB
 		wantErr bool
 	}{
-		{
-			name: "BeginStateTransaction returns error",
-			db: func(t *testing.T) db.DB {
-				mockDB := mocks.NewDB(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).
-					Return(nil, testError)
-
-				return mockDB
-			},
-			wantErr: true,
-		},
 		{
 			name: "DeleteUnresolvedBatchKeys returns error",
 			db: func(t *testing.T) db.DB {
 				mockDB := mocks.NewDB(t)
 
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("DeleteUnresolvedBatchKeys", mock.Anything, testData, mockTx).
-					Return(testError)
-
-				mockTx.On("Rollback").Return(nil)
-
-				return mockDB
-			},
-			wantErr: true,
-		},
-		{
-			name: "Commit returns error",
-			db: func(t *testing.T) db.DB {
-				mockDB := mocks.NewDB(t)
-
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("DeleteUnresolvedBatchKeys", mock.Anything, testData, mockTx).
-					Return(nil)
-
-				mockTx.On("Commit").
+				mockDB.On("DeleteUnresolvedBatchKeys", mock.Anything, testData).
 					Return(testError)
 
 				return mockDB
@@ -412,14 +289,7 @@ func Test_deleteUnresolvedBatchKeys(t *testing.T) {
 			db: func(t *testing.T) db.DB {
 				mockDB := mocks.NewDB(t)
 
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("DeleteUnresolvedBatchKeys", mock.Anything, testData, mockTx).
-					Return(nil)
-
-				mockTx.On("Commit").
+				mockDB.On("DeleteUnresolvedBatchKeys", mock.Anything, testData).
 					Return(nil)
 
 				return mockDB
@@ -454,48 +324,12 @@ func Test_storeOffchainData(t *testing.T) {
 		data    []types.OffChainData
 		wantErr bool
 	}{
-		{
-			name: "BeginStateTransaction returns error",
-			db: func(t *testing.T) db.DB {
-				mockDB := mocks.NewDB(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(nil, testError)
-
-				return mockDB
-			},
-			data:    testData,
-			wantErr: true,
-		},
 		{
 			name: "StoreOffChainData returns error",
 			db: func(t *testing.T) db.DB {
 				mockDB := mocks.NewDB(t)
 
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("StoreOffChainData", mock.Anything, testData, mockTx).Return(testError)
-
-				mockTx.On("Rollback").Return(nil)
-
-				return mockDB
-			},
-			data:    testData,
-			wantErr: true,
-		},
-		{
-			name: "Commit returns error",
-			db: func(t *testing.T) db.DB {
-				mockDB := mocks.NewDB(t)
-
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("StoreOffChainData", mock.Anything, testData, mockTx).Return(nil)
-
-				mockTx.On("Commit").Return(testError)
+				mockDB.On("StoreOffChainData", mock.Anything, testData).Return(testError)
 
 				return mockDB
 			},
@@ -507,13 +341,7 @@ func Test_storeOffchainData(t *testing.T) {
 			db: func(t *testing.T) db.DB {
 				mockDB := mocks.NewDB(t)
 
-				mockTx := mocks.NewTx(t)
-
-				mockDB.On("BeginStateTransaction", mock.Anything).Return(mockTx, nil)
-
-				mockDB.On("StoreOffChainData", mock.Anything, testData, mockTx).Return(nil)
-
-				mockTx.On("Commit").Return(nil)
+				mockDB.On("StoreOffChainData", mock.Anything, testData).Return(nil)
 
 				return mockDB
 			},