diff --git a/node/node.go b/node/node.go
index ccb316c84d..38df2d9d16 100644
--- a/node/node.go
+++ b/node/node.go
@@ -209,7 +209,7 @@ func New(cfg *Config, version string) (*Node, error) { //nolint:gocyclo,funlen
 		return nil, err
 	}
 	jsonrpcServerLegacy := jsonrpc.NewServer(maxGoroutines, log).WithValidator(validator.Validator())
-	legacyMethods, legacyPath := rpcHandler.MethodsV0_6()
+	legacyMethods, legacyPath := rpcHandler.MethodsV0_7()
 	if err = jsonrpcServerLegacy.RegisterMethods(legacyMethods...); err != nil {
 		return nil, err
 	}
diff --git a/rpc/block.go b/rpc/block.go
index 44114e9470..2902978078 100644
--- a/rpc/block.go
+++ b/rpc/block.go
@@ -193,17 +193,6 @@ func (h *Handler) BlockWithTxHashes(id BlockID) (*BlockWithTxHashes, *jsonrpc.Er
 	}, nil
 }
 
-func (h *Handler) BlockWithTxHashesV0_6(id BlockID) (*BlockWithTxHashes, *jsonrpc.Error) {
-	resp, err := h.BlockWithTxHashes(id)
-	if err != nil {
-		return nil, err
-	}
-
-	resp.L1DAMode = nil
-	resp.L1DataGasPrice = nil
-	return resp, nil
-}
-
 // BlockTransactionCount returns the number of transactions in a block
 // identified by the given BlockID.
 //
@@ -240,7 +229,7 @@ func (h *Handler) BlockWithReceipts(id BlockID) (*BlockWithReceipts, *jsonrpc.Er
 		txsWithReceipts[index] = TransactionWithReceipt{
 			Transaction: AdaptTransaction(txn),
 			// block_hash, block_number are optional in BlockWithReceipts response
-			Receipt: AdaptReceipt(r, txn, finalityStatus, nil, 0, false),
+			Receipt: AdaptReceipt(r, txn, finalityStatus, nil, 0),
 		}
 	}
 
@@ -278,17 +267,6 @@ func (h *Handler) BlockWithTxs(id BlockID) (*BlockWithTxs, *jsonrpc.Error) {
 	}, nil
 }
 
-func (h *Handler) BlockWithTxsV0_6(id BlockID) (*BlockWithTxs, *jsonrpc.Error) {
-	resp, err := h.BlockWithTxs(id)
-	if err != nil {
-		return nil, err
-	}
-
-	resp.L1DAMode = nil
-	resp.L1DataGasPrice = nil
-	return resp, nil
-}
-
 func (h *Handler) blockStatus(id BlockID, block *core.Block) (BlockStatus, *jsonrpc.Error) {
 	l1H, jsonErr := h.l1Head()
 	if jsonErr != nil {
diff --git a/rpc/block_test.go b/rpc/block_test.go
index 1db7d28553..a6cbd8fe65 100644
--- a/rpc/block_test.go
+++ b/rpc/block_test.go
@@ -604,7 +604,7 @@ func TestBlockWithReceipts(t *testing.T) {
 
 			txsWithReceipt = append(txsWithReceipt, rpc.TransactionWithReceipt{
 				Transaction: adaptedTx,
-				Receipt:     rpc.AdaptReceipt(receipt, tx, rpc.TxnAcceptedOnL2, nil, 0, false),
+				Receipt:     rpc.AdaptReceipt(receipt, tx, rpc.TxnAcceptedOnL2, nil, 0),
 			})
 		}
 
@@ -648,7 +648,7 @@ func TestBlockWithReceipts(t *testing.T) {
 
 			transactions = append(transactions, rpc.TransactionWithReceipt{
 				Transaction: adaptedTx,
-				Receipt:     rpc.AdaptReceipt(receipt, tx, rpc.TxnAcceptedOnL1, nil, 0, false),
+				Receipt:     rpc.AdaptReceipt(receipt, tx, rpc.TxnAcceptedOnL1, nil, 0),
 			})
 		}
 
diff --git a/rpc/estimate_fee.go b/rpc/estimate_fee.go
index 55aebb5a4f..3af789c4f3 100644
--- a/rpc/estimate_fee.go
+++ b/rpc/estimate_fee.go
@@ -1,7 +1,6 @@
 package rpc
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
@@ -36,27 +35,6 @@ type FeeEstimate struct {
 	DataGasPrice    *felt.Felt `json:"data_gas_price"`
 	OverallFee      *felt.Felt `json:"overall_fee"`
 	Unit            *FeeUnit   `json:"unit,omitempty"`
-	// pre 13.1 response
-	v0_6Response bool
-}
-
-func (f FeeEstimate) MarshalJSON() ([]byte, error) {
-	if f.v0_6Response {
-		return json.Marshal(struct {
-			GasConsumed *felt.Felt `json:"gas_consumed"`
-			GasPrice    *felt.Felt `json:"gas_price"`
-			OverallFee  *felt.Felt `json:"overall_fee"`
-			Unit        *FeeUnit   `json:"unit,omitempty"`
-		}{
-			GasConsumed: f.GasConsumed,
-			GasPrice:    f.GasPrice,
-			OverallFee:  f.OverallFee,
-			Unit:        f.Unit,
-		})
-	} else {
-		type alias FeeEstimate // avoid infinite recursion
-		return json.Marshal(alias(f))
-	}
 }
 
 /****************************************************
@@ -66,20 +44,7 @@ func (f FeeEstimate) MarshalJSON() ([]byte, error) {
 func (h *Handler) EstimateFee(broadcastedTxns []BroadcastedTransaction,
 	simulationFlags []SimulationFlag, id BlockID,
 ) ([]FeeEstimate, http.Header, *jsonrpc.Error) {
-	result, httpHeader, err := h.simulateTransactions(id, broadcastedTxns, append(simulationFlags, SkipFeeChargeFlag), false, true)
-	if err != nil {
-		return nil, httpHeader, err
-	}
-
-	return utils.Map(result, func(tx SimulatedTransaction) FeeEstimate {
-		return tx.FeeEstimation
-	}), httpHeader, nil
-}
-
-func (h *Handler) EstimateFeeV0_6(broadcastedTxns []BroadcastedTransaction,
-	simulationFlags []SimulationFlag, id BlockID,
-) ([]FeeEstimate, http.Header, *jsonrpc.Error) {
-	result, httpHeader, err := h.simulateTransactions(id, broadcastedTxns, append(simulationFlags, SkipFeeChargeFlag), true, true)
+	result, httpHeader, err := h.simulateTransactions(id, broadcastedTxns, append(simulationFlags, SkipFeeChargeFlag), true)
 	if err != nil {
 		return nil, httpHeader, err
 	}
@@ -93,19 +58,6 @@ func (h *Handler) EstimateMessageFee(msg MsgFromL1, id BlockID) (*FeeEstimate, h
 	return h.estimateMessageFee(msg, id, h.EstimateFee)
 }
 
-func (h *Handler) EstimateMessageFeeV0_6(msg MsgFromL1, id BlockID) (*FeeEstimate, http.Header, *jsonrpc.Error) { //nolint:gocritic
-	feeEstimate, httpHeader, rpcErr := h.estimateMessageFee(msg, id, h.EstimateFeeV0_6)
-	if rpcErr != nil {
-		return nil, httpHeader, rpcErr
-	}
-
-	feeEstimate.v0_6Response = true
-	feeEstimate.DataGasPrice = nil
-	feeEstimate.DataGasConsumed = nil
-
-	return feeEstimate, httpHeader, nil
-}
-
 type estimateFeeHandler func(broadcastedTxns []BroadcastedTransaction,
 	simulationFlags []SimulationFlag, id BlockID,
 ) ([]FeeEstimate, http.Header, *jsonrpc.Error)
diff --git a/rpc/estimate_fee_test.go b/rpc/estimate_fee_test.go
index d075e5a0c7..ec4bdf3635 100644
--- a/rpc/estimate_fee_test.go
+++ b/rpc/estimate_fee_test.go
@@ -3,101 +3,19 @@ package rpc_test
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"testing"
 
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
-	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/mocks"
 	"github.com/NethermindEth/juno/rpc"
 	"github.com/NethermindEth/juno/utils"
 	"github.com/NethermindEth/juno/vm"
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
 )
 
-func TestEstimateMessageFeeV0_6(t *testing.T) {
-	mockCtrl := gomock.NewController(t)
-	t.Cleanup(mockCtrl.Finish)
-
-	n := utils.Ptr(utils.Mainnet)
-	mockReader := mocks.NewMockReader(mockCtrl)
-	mockReader.EXPECT().Network().Return(n).AnyTimes()
-	mockVM := mocks.NewMockVM(mockCtrl)
-
-	handler := rpc.New(mockReader, nil, mockVM, "", utils.NewNopZapLogger())
-	msg := rpc.MsgFromL1{
-		From:     common.HexToAddress("0xDEADBEEF"),
-		To:       *new(felt.Felt).SetUint64(1337),
-		Payload:  []felt.Felt{*new(felt.Felt).SetUint64(1), *new(felt.Felt).SetUint64(2)},
-		Selector: *new(felt.Felt).SetUint64(44),
-	}
-
-	t.Run("block not found", func(t *testing.T) {
-		mockReader.EXPECT().HeadState().Return(nil, nil, db.ErrKeyNotFound)
-		_, httpHeader, err := handler.EstimateMessageFeeV0_6(msg, rpc.BlockID{Latest: true})
-		require.Equal(t, rpc.ErrBlockNotFound, err)
-		require.NotEmpty(t, httpHeader.Get(rpc.ExecutionStepsHeader))
-	})
-
-	latestHeader := &core.Header{
-		Number:    9,
-		Timestamp: 456,
-		GasPrice:  new(felt.Felt).SetUint64(42),
-	}
-	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
-
-	mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
-	mockReader.EXPECT().HeadsHeader().Return(latestHeader, nil)
-
-	expectedGasConsumed := new(felt.Felt).SetUint64(37)
-	mockVM.EXPECT().Execute(gomock.Any(), gomock.Any(), gomock.Any(), &vm.BlockInfo{
-		Header: latestHeader,
-	}, gomock.Any(), &utils.Mainnet, gomock.Any(), false, true, false).DoAndReturn(
-		func(txns []core.Transaction, declaredClasses []core.Class, paidFeesOnL1 []*felt.Felt, blockInfo *vm.BlockInfo,
-			state core.StateReader, network *utils.Network, skipChargeFee, skipValidate, errOnRevert, useBlobData bool,
-		) ([]*felt.Felt, []core.GasConsumed, []vm.TransactionTrace, uint64, error) {
-			require.Len(t, txns, 1)
-			assert.NotNil(t, txns[0].(*core.L1HandlerTransaction))
-
-			assert.Empty(t, declaredClasses)
-			assert.Len(t, paidFeesOnL1, 1)
-
-			actualFee := new(felt.Felt).Mul(expectedGasConsumed, blockInfo.Header.GasPrice)
-			daGas := []core.GasConsumed{{L1Gas: 0, L1DataGas: 0}}
-			return []*felt.Felt{actualFee}, daGas, []vm.TransactionTrace{{
-				StateDiff: &vm.StateDiff{
-					StorageDiffs:              []vm.StorageDiff{},
-					Nonces:                    []vm.Nonce{},
-					DeployedContracts:         []vm.DeployedContract{},
-					DeprecatedDeclaredClasses: []*felt.Felt{},
-					DeclaredClasses:           []vm.DeclaredClass{},
-					ReplacedClasses:           []vm.ReplacedClass{},
-				},
-			}}, uint64(123), nil
-		},
-	)
-
-	estimateFee, httpHeader, err := handler.EstimateMessageFeeV0_6(msg, rpc.BlockID{Latest: true})
-	require.Nil(t, err)
-	expectedJSON := fmt.Sprintf(
-		`{"gas_consumed":%q,"gas_price":%q,"overall_fee":%q,"unit":"WEI"}`,
-		expectedGasConsumed,
-		latestHeader.GasPrice,
-		new(felt.Felt).Mul(expectedGasConsumed, latestHeader.GasPrice),
-	)
-
-	// we check json response here because some fields are private and we can't set them and assert.Equal fails
-	// also in 0.6 response some fields should not be presented
-	estimateFeeJSON, jsonErr := json.Marshal(estimateFee)
-	require.NoError(t, jsonErr)
-	require.Equal(t, expectedJSON, string(estimateFeeJSON))
-	require.NotEmpty(t, httpHeader.Get(rpc.ExecutionStepsHeader))
-}
-
 func TestEstimateFee(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
diff --git a/rpc/handlers.go b/rpc/handlers.go
index cfaf1f37a1..e4ef621671 100644
--- a/rpc/handlers.go
+++ b/rpc/handlers.go
@@ -68,8 +68,7 @@ const (
 )
 
 type traceCacheKey struct {
-	blockHash    felt.Felt
-	v0_6Response bool
+	blockHash felt.Felt
 }
 
 type Handler struct {
@@ -164,14 +163,14 @@ func (h *Handler) Version() (string, *jsonrpc.Error) {
 }
 
 func (h *Handler) SpecVersion() (string, *jsonrpc.Error) {
-	return "0.7.1", nil
+	return "0.8.0", nil
 }
 
-func (h *Handler) SpecVersionV0_6() (string, *jsonrpc.Error) {
-	return "0.6.0", nil
+func (h *Handler) SpecVersionV0_7() (string, *jsonrpc.Error) {
+	return "0.7.1", nil
 }
 
-func (h *Handler) Methods() ([]jsonrpc.Method, string) { //nolint: funlen
+func (h *Handler) Methods() ([]jsonrpc.Method, string) { //nolint: funlen, dupl
 	return []jsonrpc.Method{
 		{
 			Name:    "starknet_chainId",
@@ -326,10 +325,10 @@ func (h *Handler) Methods() ([]jsonrpc.Method, string) { //nolint: funlen
 			Params:  []jsonrpc.Parameter{{Name: "block_id"}},
 			Handler: h.BlockWithReceipts,
 		},
-	}, "/v0_7"
+	}, "/v0_8"
 }
 
-func (h *Handler) MethodsV0_6() ([]jsonrpc.Method, string) { //nolint: funlen
+func (h *Handler) MethodsV0_7() ([]jsonrpc.Method, string) { //nolint: funlen, dupl
 	return []jsonrpc.Method{
 		{
 			Name:    "starknet_chainId",
@@ -346,12 +345,12 @@ func (h *Handler) MethodsV0_6() ([]jsonrpc.Method, string) { //nolint: funlen
 		{
 			Name:    "starknet_getBlockWithTxHashes",
 			Params:  []jsonrpc.Parameter{{Name: "block_id"}},
-			Handler: h.BlockWithTxHashesV0_6,
+			Handler: h.BlockWithTxHashes,
 		},
 		{
 			Name:    "starknet_getBlockWithTxs",
 			Params:  []jsonrpc.Parameter{{Name: "block_id"}},
-			Handler: h.BlockWithTxsV0_6,
+			Handler: h.BlockWithTxs,
 		},
 		{
 			Name:    "starknet_getTransactionByHash",
@@ -361,7 +360,7 @@ func (h *Handler) MethodsV0_6() ([]jsonrpc.Method, string) { //nolint: funlen
 		{
 			Name:    "starknet_getTransactionReceipt",
 			Params:  []jsonrpc.Parameter{{Name: "transaction_hash"}},
-			Handler: h.TransactionReceiptByHashV0_6,
+			Handler: h.TransactionReceiptByHash,
 		},
 		{
 			Name:    "starknet_getBlockTransactionCount",
@@ -439,36 +438,36 @@ func (h *Handler) MethodsV0_6() ([]jsonrpc.Method, string) { //nolint: funlen
 		{
 			Name:    "starknet_call",
 			Params:  []jsonrpc.Parameter{{Name: "request"}, {Name: "block_id"}},
-			Handler: h.CallV0_6,
+			Handler: h.Call,
 		},
 		{
 			Name:    "starknet_estimateFee",
 			Params:  []jsonrpc.Parameter{{Name: "request"}, {Name: "simulation_flags"}, {Name: "block_id"}},
-			Handler: h.EstimateFeeV0_6,
+			Handler: h.EstimateFee,
 		},
 		{
 			Name:    "starknet_estimateMessageFee",
 			Params:  []jsonrpc.Parameter{{Name: "message"}, {Name: "block_id"}},
-			Handler: h.EstimateMessageFeeV0_6,
+			Handler: h.EstimateMessageFee,
 		},
 		{
 			Name:    "starknet_traceTransaction",
 			Params:  []jsonrpc.Parameter{{Name: "transaction_hash"}},
-			Handler: h.TraceTransactionV0_6,
+			Handler: h.TraceTransaction,
 		},
 		{
 			Name:    "starknet_simulateTransactions",
 			Params:  []jsonrpc.Parameter{{Name: "block_id"}, {Name: "transactions"}, {Name: "simulation_flags"}},
-			Handler: h.SimulateTransactionsV0_6,
+			Handler: h.SimulateTransactions,
 		},
 		{
 			Name:    "starknet_traceBlockTransactions",
 			Params:  []jsonrpc.Parameter{{Name: "block_id"}},
-			Handler: h.TraceBlockTransactionsV0_6,
+			Handler: h.TraceBlockTransactions,
 		},
 		{
 			Name:    "starknet_specVersion",
-			Handler: h.SpecVersionV0_6,
+			Handler: h.SpecVersion,
 		},
 		{
 			Name:    "juno_subscribeNewHeads",
@@ -479,5 +478,10 @@ func (h *Handler) MethodsV0_6() ([]jsonrpc.Method, string) { //nolint: funlen
 			Params:  []jsonrpc.Parameter{{Name: "id"}},
 			Handler: h.Unsubscribe,
 		},
-	}, "/v0_6"
+		{
+			Name:    "starknet_getBlockWithReceipts",
+			Params:  []jsonrpc.Parameter{{Name: "block_id"}},
+			Handler: h.BlockWithReceipts,
+		},
+	}, "/v0_7"
 }
diff --git a/rpc/handlers_test.go b/rpc/handlers_test.go
index c34b7727dd..af5e9ae7a6 100644
--- a/rpc/handlers_test.go
+++ b/rpc/handlers_test.go
@@ -30,11 +30,11 @@ func TestSpecVersion(t *testing.T) {
 	handler := rpc.New(nil, nil, nil, "", nil)
 	version, rpcErr := handler.SpecVersion()
 	require.Nil(t, rpcErr)
-	require.Equal(t, "0.7.1", version)
+	require.Equal(t, "0.8.0", version)
 
-	legacyVersion, rpcErr := handler.SpecVersionV0_6()
+	legacyVersion, rpcErr := handler.SpecVersionV0_7()
 	require.Nil(t, rpcErr)
-	require.Equal(t, "0.6.0", legacyVersion)
+	require.Equal(t, "0.7.1", legacyVersion)
 }
 
 func TestThrottledVMError(t *testing.T) {
diff --git a/rpc/helpers.go b/rpc/helpers.go
index 50db59c1e3..dae08c5ff4 100644
--- a/rpc/helpers.go
+++ b/rpc/helpers.go
@@ -87,15 +87,10 @@ func (h *Handler) blockHeaderByID(id *BlockID) (*core.Header, *jsonrpc.Error) {
 	return header, nil
 }
 
-func adaptExecutionResources(resources *core.ExecutionResources, v0_6Response bool) *ExecutionResources {
+func adaptExecutionResources(resources *core.ExecutionResources) *ExecutionResources {
 	if resources == nil {
-		var dataAvailability *DataAvailability
-		if !v0_6Response {
-			dataAvailability = &DataAvailability{}
-		}
-
 		return &ExecutionResources{
-			DataAvailability: dataAvailability,
+			DataAvailability: &DataAvailability{},
 		}
 	}
 
@@ -112,15 +107,12 @@ func adaptExecutionResources(resources *core.ExecutionResources, v0_6Response bo
 			Poseidon:     resources.BuiltinInstanceCounter.Poseidon,
 			SegmentArena: resources.BuiltinInstanceCounter.SegmentArena,
 		},
+		DataAvailability: &DataAvailability{},
 	}
-	if !v0_6Response {
-		if resources.DataAvailability == nil {
-			res.DataAvailability = &DataAvailability{}
-		} else {
-			res.DataAvailability = &DataAvailability{
-				L1Gas:     resources.DataAvailability.L1Gas,
-				L1DataGas: resources.DataAvailability.L1DataGas,
-			}
+	if resources.DataAvailability != nil {
+		res.DataAvailability = &DataAvailability{
+			L1Gas:     resources.DataAvailability.L1Gas,
+			L1DataGas: resources.DataAvailability.L1DataGas,
 		}
 	}
 
diff --git a/rpc/simulation.go b/rpc/simulation.go
index 940fabdd90..bc065fe2e3 100644
--- a/rpc/simulation.go
+++ b/rpc/simulation.go
@@ -53,21 +53,11 @@ type TracedBlockTransaction struct {
 func (h *Handler) SimulateTransactions(id BlockID, transactions []BroadcastedTransaction,
 	simulationFlags []SimulationFlag,
 ) ([]SimulatedTransaction, http.Header, *jsonrpc.Error) {
-	return h.simulateTransactions(id, transactions, simulationFlags, false, false)
-}
-
-// pre 13.1
-func (h *Handler) SimulateTransactionsV0_6(id BlockID, transactions []BroadcastedTransaction,
-	simulationFlags []SimulationFlag,
-) ([]SimulatedTransaction, http.Header, *jsonrpc.Error) {
-	// todo double check errOnRevert = false
-	return h.simulateTransactions(id, transactions, simulationFlags, true, false)
+	return h.simulateTransactions(id, transactions, simulationFlags, false)
 }
 
 //nolint:funlen,gocyclo
-func (h *Handler) simulateTransactions(id BlockID, transactions []BroadcastedTransaction,
-	simulationFlags []SimulationFlag, v0_6Response, errOnRevert bool,
-) ([]SimulatedTransaction, http.Header, *jsonrpc.Error) {
+func (h *Handler) simulateTransactions(id BlockID, transactions []BroadcastedTransaction, simulationFlags []SimulationFlag, errOnRevert bool) ([]SimulatedTransaction, http.Header, *jsonrpc.Error) {
 	skipFeeCharge := slices.Contains(simulationFlags, SkipFeeChargeFlag)
 	skipValidate := slices.Contains(simulationFlags, SkipValidateFlag)
 
@@ -113,7 +103,7 @@ func (h *Handler) simulateTransactions(id BlockID, transactions []BroadcastedTra
 		Header:                header,
 		BlockHashToBeRevealed: blockHashToBeRevealed,
 	}
-	useBlobData := !v0_6Response
+	useBlobData := true
 	overallFees, daGas, traces, numSteps, err := h.vm.Execute(txns, classes, paidFeesOnL1, &blockInfo,
 		state, h.bcReader.Network(), skipFeeCharge, skipValidate, errOnRevert, useBlobData)
 
@@ -153,12 +143,8 @@ func (h *Handler) simulateTransactions(id BlockID, transactions []BroadcastedTra
 
 		var gasConsumed *felt.Felt
 		daGasL1DataGas := new(felt.Felt).SetUint64(daGas[i].L1DataGas)
-		if !v0_6Response {
-			dataGasFee := new(felt.Felt).Mul(daGasL1DataGas, dataGasPrice)
-			gasConsumed = new(felt.Felt).Sub(overallFee, dataGasFee)
-		} else {
-			gasConsumed = overallFee.Clone()
-		}
+		dataGasFee := new(felt.Felt).Mul(daGasL1DataGas, dataGasPrice)
+		gasConsumed = new(felt.Felt).Sub(overallFee, dataGasFee)
 		gasConsumed = gasConsumed.Div(gasConsumed, gasPrice) // division by zero felt is zero felt
 
 		estimate := FeeEstimate{
@@ -168,18 +154,15 @@ func (h *Handler) simulateTransactions(id BlockID, transactions []BroadcastedTra
 			DataGasPrice:    dataGasPrice,
 			OverallFee:      overallFee,
 			Unit:            utils.Ptr(feeUnit),
-			v0_6Response:    v0_6Response,
 		}
 
-		if !v0_6Response {
-			trace := traces[i]
-			executionResources := trace.TotalExecutionResources()
-			executionResources.DataAvailability = &vm.DataAvailability{
-				L1Gas:     daGas[i].L1Gas,
-				L1DataGas: daGas[i].L1DataGas,
-			}
-			traces[i].ExecutionResources = executionResources
+		trace := traces[i]
+		executionResources := trace.TotalExecutionResources()
+		executionResources.DataAvailability = &vm.DataAvailability{
+			L1Gas:     daGas[i].L1Gas,
+			L1DataGas: daGas[i].L1DataGas,
 		}
+		traces[i].ExecutionResources = executionResources
 
 		result = append(result, SimulatedTransaction{
 			TransactionTrace: &traces[i],
diff --git a/rpc/trace.go b/rpc/trace.go
index 0faeed20b2..6df386f26e 100644
--- a/rpc/trace.go
+++ b/rpc/trace.go
@@ -132,16 +132,10 @@ func adaptFeederExecutionResources(resources *starknet.ExecutionResources) *vm.E
 // It follows the specification defined here:
 // https://github.com/starkware-libs/starknet-specs/blob/1ae810e0137cc5d175ace4554892a4f43052be56/api/starknet_trace_api_openrpc.json#L11
 func (h *Handler) TraceTransaction(ctx context.Context, hash felt.Felt) (*vm.TransactionTrace, http.Header, *jsonrpc.Error) {
-	return h.traceTransaction(ctx, &hash, false)
+	return h.traceTransaction(ctx, &hash)
 }
 
-func (h *Handler) TraceTransactionV0_6(ctx context.Context, hash felt.Felt) (*vm.TransactionTrace, http.Header, *jsonrpc.Error) {
-	return h.traceTransaction(ctx, &hash, true)
-}
-
-func (h *Handler) traceTransaction(ctx context.Context, hash *felt.Felt, v0_6Response bool) (*vm.TransactionTrace,
-	http.Header, *jsonrpc.Error,
-) {
+func (h *Handler) traceTransaction(ctx context.Context, hash *felt.Felt) (*vm.TransactionTrace, http.Header, *jsonrpc.Error) {
 	_, blockHash, _, err := h.bcReader.Receipt(hash)
 	httpHeader := http.Header{}
 	httpHeader.Set(ExecutionStepsHeader, "0")
@@ -175,7 +169,7 @@ func (h *Handler) traceTransaction(ctx context.Context, hash *felt.Felt, v0_6Res
 		return nil, httpHeader, ErrTxnHashNotFound
 	}
 
-	traceResults, header, traceBlockErr := h.traceBlockTransactions(ctx, block, v0_6Response)
+	traceResults, header, traceBlockErr := h.traceBlockTransactions(ctx, block)
 	if traceBlockErr != nil {
 		return nil, header, traceBlockErr
 	}
@@ -191,20 +185,10 @@ func (h *Handler) TraceBlockTransactions(ctx context.Context, id BlockID) ([]Tra
 		return nil, httpHeader, rpcErr
 	}
 
-	return h.traceBlockTransactions(ctx, block, false)
+	return h.traceBlockTransactions(ctx, block)
 }
 
-func (h *Handler) TraceBlockTransactionsV0_6(ctx context.Context, id BlockID) ([]TracedBlockTransaction, http.Header, *jsonrpc.Error) {
-	block, rpcErr := h.blockByID(&id)
-	if rpcErr != nil {
-		return nil, nil, rpcErr
-	}
-
-	return h.traceBlockTransactions(ctx, block, true)
-}
-
-func (h *Handler) traceBlockTransactions(ctx context.Context, block *core.Block, v0_6Response bool, //nolint: gocyclo, funlen
-) ([]TracedBlockTransaction, http.Header, *jsonrpc.Error) {
+func (h *Handler) traceBlockTransactions(ctx context.Context, block *core.Block) ([]TracedBlockTransaction, http.Header, *jsonrpc.Error) {
 	httpHeader := http.Header{}
 	httpHeader.Set(ExecutionStepsHeader, "0")
 
@@ -219,38 +203,35 @@ func (h *Handler) traceBlockTransactions(ctx context.Context, block *core.Block,
 				return nil, httpHeader, err
 			}
 
-			if !v0_6Response {
-				txDataAvailability := make(map[felt.Felt]vm.DataAvailability, len(block.Receipts))
-				for _, receipt := range block.Receipts {
-					if receipt.ExecutionResources == nil {
-						continue
-					}
-					if receiptDA := receipt.ExecutionResources.DataAvailability; receiptDA != nil {
-						da := vm.DataAvailability{
-							L1Gas:     receiptDA.L1Gas,
-							L1DataGas: receiptDA.L1DataGas,
-						}
-						txDataAvailability[*receipt.TransactionHash] = da
+			txDataAvailability := make(map[felt.Felt]vm.DataAvailability, len(block.Receipts))
+			for _, receipt := range block.Receipts {
+				if receipt.ExecutionResources == nil {
+					continue
+				}
+				if receiptDA := receipt.ExecutionResources.DataAvailability; receiptDA != nil {
+					da := vm.DataAvailability{
+						L1Gas:     receiptDA.L1Gas,
+						L1DataGas: receiptDA.L1DataGas,
 					}
+					txDataAvailability[*receipt.TransactionHash] = da
 				}
+			}
 
-				// add execution resources on root level
-				for index, trace := range result {
-					executionResources := trace.TraceRoot.TotalExecutionResources()
-					// fgw doesn't provide this data in traces endpoint
-					// some receipts don't have data availability data in this case we don't
-					da := txDataAvailability[*trace.TransactionHash]
-					executionResources.DataAvailability = &da
-					result[index].TraceRoot.ExecutionResources = executionResources
-				}
+			// add execution resources on root level
+			for index, trace := range result {
+				executionResources := trace.TraceRoot.TotalExecutionResources()
+				// fgw doesn't provide this data in traces endpoint
+				// some receipts don't have data availability data in this case we don't
+				da := txDataAvailability[*trace.TransactionHash]
+				executionResources.DataAvailability = &da
+				result[index].TraceRoot.ExecutionResources = executionResources
 			}
 
 			return result, httpHeader, err
 		}
 
 		if trace, hit := h.blockTraceCache.Get(traceCacheKey{
-			blockHash:    *block.Hash,
-			v0_6Response: v0_6Response,
+			blockHash: *block.Hash,
 		}); hit {
 			return trace, httpHeader, nil
 		}
@@ -304,7 +285,7 @@ func (h *Handler) traceBlockTransactions(ctx context.Context, block *core.Block,
 		BlockHashToBeRevealed: blockHashToBeRevealed,
 	}
 
-	useBlobData := !v0_6Response
+	useBlobData := true
 	_, daGas, traces, numSteps, err := h.vm.Execute(block.Transactions, classes, paidFeesOnL1,
 		&blockInfo, state, network, false, false, false, useBlobData)
 
@@ -321,14 +302,12 @@ func (h *Handler) traceBlockTransactions(ctx context.Context, block *core.Block,
 
 	result := make([]TracedBlockTransaction, 0, len(traces))
 	for index, trace := range traces {
-		if !v0_6Response {
-			executionResources := trace.TotalExecutionResources()
-			executionResources.DataAvailability = &vm.DataAvailability{
-				L1Gas:     daGas[index].L1Gas,
-				L1DataGas: daGas[index].L1DataGas,
-			}
-			traces[index].ExecutionResources = executionResources
+		executionResources := trace.TotalExecutionResources()
+		executionResources.DataAvailability = &vm.DataAvailability{
+			L1Gas:     daGas[index].L1Gas,
+			L1DataGas: daGas[index].L1DataGas,
 		}
+		traces[index].ExecutionResources = executionResources
 		result = append(result, TracedBlockTransaction{
 			TraceRoot:       &traces[index],
 			TransactionHash: block.Transactions[index].Hash(),
@@ -337,8 +316,7 @@ func (h *Handler) traceBlockTransactions(ctx context.Context, block *core.Block,
 
 	if !isPending {
 		h.blockTraceCache.Add(traceCacheKey{
-			blockHash:    *block.Hash,
-			v0_6Response: v0_6Response,
+			blockHash: *block.Hash,
 		}, result)
 	}
 
@@ -372,14 +350,6 @@ func (h *Handler) fetchTraces(ctx context.Context, blockHash *felt.Felt) ([]Trac
 
 // https://github.com/starkware-libs/starknet-specs/blob/e0b76ed0d8d8eba405e182371f9edac8b2bcbc5a/api/starknet_api_openrpc.json#L401-L445
 func (h *Handler) Call(funcCall FunctionCall, id BlockID) ([]*felt.Felt, *jsonrpc.Error) { //nolint:gocritic
-	return h.call(funcCall, id, true)
-}
-
-func (h *Handler) CallV0_6(call FunctionCall, id BlockID) ([]*felt.Felt, *jsonrpc.Error) { //nolint:gocritic
-	return h.call(call, id, false)
-}
-
-func (h *Handler) call(funcCall FunctionCall, id BlockID, useBlobData bool) ([]*felt.Felt, *jsonrpc.Error) { //nolint:gocritic
 	state, closer, rpcErr := h.stateByBlockID(&id)
 	if rpcErr != nil {
 		return nil, rpcErr
@@ -409,7 +379,7 @@ func (h *Handler) call(funcCall FunctionCall, id BlockID, useBlobData bool) ([]*
 	}, &vm.BlockInfo{
 		Header:                header,
 		BlockHashToBeRevealed: blockHashToBeRevealed,
-	}, state, h.bcReader.Network(), h.callMaxSteps, useBlobData)
+	}, state, h.bcReader.Network(), h.callMaxSteps, true)
 	if err != nil {
 		if errors.Is(err, utils.ErrResourceBusy) {
 			return nil, ErrInternal.CloneWithData(throttledVMErr)
diff --git a/rpc/transaction.go b/rpc/transaction.go
index b8269b5342..5e35c4569d 100644
--- a/rpc/transaction.go
+++ b/rpc/transaction.go
@@ -495,38 +495,7 @@ func (h *Handler) TransactionReceiptByHash(hash felt.Felt) (*TransactionReceipt,
 		}
 	}
 
-	return AdaptReceipt(receipt, txn, status, blockHash, blockNumber, false), nil
-}
-
-// TransactionReceiptByHash returns the receipt of a transaction identified by the given hash.
-//
-// It follows the specification defined here:
-// https://github.com/starkware-libs/starknet-specs/blob/master/api/starknet_api_openrpc.json#L222
-func (h *Handler) TransactionReceiptByHashV0_6(hash felt.Felt) (*TransactionReceipt, *jsonrpc.Error) { //nolint:dupl
-	txn, err := h.bcReader.TransactionByHash(&hash)
-	if err != nil {
-		return nil, ErrTxnHashNotFound
-	}
-
-	receipt, blockHash, blockNumber, err := h.bcReader.Receipt(&hash)
-	if err != nil {
-		return nil, ErrTxnHashNotFound
-	}
-
-	status := TxnAcceptedOnL2
-
-	if blockHash != nil {
-		l1H, jsonErr := h.l1Head()
-		if jsonErr != nil {
-			return nil, jsonErr
-		}
-
-		if isL1Verified(blockNumber, l1H) {
-			status = TxnAcceptedOnL1
-		}
-	}
-
-	return AdaptReceipt(receipt, txn, status, blockHash, blockNumber, true), nil
+	return AdaptReceipt(receipt, txn, status, blockHash, blockNumber), nil
 }
 
 // AddTransaction relays a transaction to the gateway.
@@ -706,9 +675,8 @@ func AdaptTransaction(t core.Transaction) *Transaction {
 }
 
 // todo(Kirill): try to replace core.Transaction with rpc.Transaction type
-func AdaptReceipt(receipt *core.TransactionReceipt, txn core.Transaction,
-	finalityStatus TxnFinalityStatus, blockHash *felt.Felt, blockNumber uint64,
-	v0_6Response bool,
+func AdaptReceipt(receipt *core.TransactionReceipt, txn core.Transaction, finalityStatus TxnFinalityStatus,
+	blockHash *felt.Felt, blockNumber uint64,
 ) *TransactionReceipt {
 	messages := make([]*MsgToL1, len(receipt.L2ToL1Message))
 	for idx, msg := range receipt.L2ToL1Message {
@@ -767,7 +735,7 @@ func AdaptReceipt(receipt *core.TransactionReceipt, txn core.Transaction,
 		Events:             events,
 		ContractAddress:    contractAddress,
 		RevertReason:       receipt.RevertReason,
-		ExecutionResources: adaptExecutionResources(receipt.ExecutionResources, v0_6Response),
+		ExecutionResources: adaptExecutionResources(receipt.ExecutionResources),
 		MessageHash:        messageHash,
 	}
 }