Add 0.6 rpc endpoints

adapters/core2p2p/receipt.go

@@ -107,7 +107,6 @@ func AdaptExecutionResources(er *core.ExecutionResources) *gen.Receipt_Execution
 	var l1Gas, l1DataGas, l2Gas, totalL1Gas, totalL1DataGas *felt.Felt
 	if da := er.DataAvailability; da != nil { // todo(kirill) check that it might be null
 		l1Gas = new(felt.Felt).SetUint64(da.L1Gas)
-		l2Gas = new(felt.Felt).SetUint64(da.L2Gas)
 		l1DataGas = new(felt.Felt).SetUint64(da.L1DataGas)
 	}
 	if tgs := er.TotalGasConsumed; tgs != nil {

adapters/p2p2core/receipt.go

@@ -58,7 +58,6 @@ func adaptExecutionResources(er *gen.Receipt_ExecutionResources) *core.Execution
 		},
 		DataAvailability: &core.DataAvailability{
 			L1Gas:     feltToUint64(er.L1Gas),
-			L2Gas:     feltToUint64(er.L2Gas),
 			L1DataGas: feltToUint64(er.L1DataGas),
 		},
 		MemoryHoles: uint64(er.MemoryHoles),

core/transaction.go

@@ -105,7 +105,6 @@ type ExecutionResources struct {
 type DataAvailability struct {
 	L1Gas     uint64
 	L1DataGas uint64
-	L2Gas     uint64
 }
 
 type BuiltinInstanceCounter struct {

go.mod

@@ -33,6 +33,7 @@ require (
 	go.uber.org/mock v0.5.0
 	go.uber.org/zap v1.27.0
 	golang.org/x/crypto v0.32.0
+	golang.org/x/exp v0.0.0-20241217172543-b2144cdd0a67
 	google.golang.org/grpc v1.70.0
 	google.golang.org/protobuf v1.36.4
 	gopkg.in/yaml.v3 v3.0.1
@@ -188,7 +189,6 @@ require (
 	go.uber.org/dig v1.18.0 // indirect
 	go.uber.org/fx v1.23.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/exp v0.0.0-20241217172543-b2144cdd0a67 // indirect
 	golang.org/x/mod v0.22.0 // indirect
 	golang.org/x/net v0.34.0 // indirect
 	golang.org/x/sync v0.10.0 // indirect

node/node.go

@@ -210,18 +210,28 @@
 	if err = jsonrpcServer.RegisterMethods(methods...); err != nil {
 		return nil, err
 	}
-	jsonrpcServerLegacy := jsonrpc.NewServer(maxGoroutines, log).WithValidator(validator.Validator())
-	legacyMethods, legacyPath := rpcHandler.MethodsV0_7()
-	if err = jsonrpcServerLegacy.RegisterMethods(legacyMethods...); err != nil {
+
+	jsonrpcServerV0_6 := jsonrpc.NewServer(maxGoroutines, log).WithValidator(validator.Validator())
+	methodsV0_6, pathV0_6 := rpcHandler.MethodsV0_6()
+	if err = jsonrpcServerV0_6.RegisterMethods(methodsV0_6...); err != nil {
 		return nil, err
 	}
+
+	jsonrpcServerV0_7 := jsonrpc.NewServer(maxGoroutines, log).WithValidator(validator.Validator())
+	methodsV0_7, pathV0_7 := rpcHandler.MethodsV0_7()
+	if err = jsonrpcServerV0_7.RegisterMethods(methodsV0_7...); err != nil {
+		return nil, err
+	}
+
 	rpcServers := map[string]*jsonrpc.Server{
-		"/":                 jsonrpcServer,
-		path:                jsonrpcServer,
-		legacyPath:          jsonrpcServerLegacy,
-		"/rpc":              jsonrpcServer,
-		"/rpc" + path:       jsonrpcServer,
-		"/rpc" + legacyPath: jsonrpcServerLegacy,
+		"/":               jsonrpcServer,
+		path:              jsonrpcServer,
+		pathV0_7:          jsonrpcServerV0_7,
+		pathV0_6:          jsonrpcServerV0_6,
+		"/rpc":            jsonrpcServer,
+		"/rpc" + path:     jsonrpcServer,
+		"/rpc" + pathV0_7: jsonrpcServerV0_7,
+		"/rpc" + pathV0_6: jsonrpcServerV0_6,
 	}
 	if cfg.HTTP {
 		readinessHandlers := NewReadinessHandlers(chain, synchronizer)
@@ -242,9 +252,9 @@
 		chain.WithListener(makeBlockchainMetrics())
 		makeJunoMetrics(version)
 		database.WithListener(makeDBMetrics())
-		rpcMetrics, legacyRPCMetrics := makeRPCMetrics(path, legacyPath)
+		rpcMetrics, legacyRPCMetrics := makeRPCMetrics(path, pathV0_7)
 		jsonrpcServer.WithListener(rpcMetrics)
-		jsonrpcServerLegacy.WithListener(legacyRPCMetrics)
+		jsonrpcServerV0_7.WithListener(legacyRPCMetrics)
 		client.WithListener(makeFeederMetrics())
 		gatewayClient.WithListener(makeGatewayMetrics())
 		metricsService = makeMetrics(cfg.MetricsHost, cfg.MetricsPort)

node/throttled_vm.go

@@ -15,23 +15,24 @@
 
 func NewThrottledVM(res vm.VM, concurrenyBudget uint, maxQueueLen int32) *ThrottledVM {
 	return &ThrottledVM{
-		Throttler: utils.NewThrottler[vm.VM](concurrenyBudget, &res).WithMaxQueueLen(maxQueueLen),
+		Throttler: utils.NewThrottler(concurrenyBudget, &res).WithMaxQueueLen(maxQueueLen),
 	}
 }
 
 func (tvm *ThrottledVM) Call(callInfo *vm.CallInfo, blockInfo *vm.BlockInfo, state core.StateReader,
-	network *utils.Network, maxSteps uint64,
+	network *utils.Network, maxSteps uint64, useBlobData bool,
 ) ([]*felt.Felt, error) {
 	var ret []*felt.Felt
 	return ret, tvm.Do(func(vm *vm.VM) error {
 		var err error
-		ret, err = (*vm).Call(callInfo, blockInfo, state, network, maxSteps)
+		ret, err = (*vm).Call(callInfo, blockInfo, state, network, maxSteps, useBlobData)
 		return err
 	})
 }
 
 func (tvm *ThrottledVM) Execute(txns []core.Transaction, declaredClasses []core.Class, paidFeesOnL1 []*felt.Felt,
 	blockInfo *vm.BlockInfo, state core.StateReader, network *utils.Network, skipChargeFee, skipValidate, errOnRevert bool,
+	useBlobData bool,
 ) ([]*felt.Felt, []core.GasConsumed, []vm.TransactionTrace, uint64, error) {
 	var ret []*felt.Felt
 	var traces []vm.TransactionTrace
@@ -40,7 +41,7 @@
 	return ret, daGas, traces, numSteps, tvm.Do(func(vm *vm.VM) error {
 		var err error
 		ret, daGas, traces, numSteps, err = (*vm).Execute(txns, declaredClasses, paidFeesOnL1, blockInfo, state, network,
-			skipChargeFee, skipValidate, errOnRevert)
+			skipChargeFee, skipValidate, errOnRevert, useBlobData)
 		return err
 	})
 }

rpc/block.go

@@ -107,7 +107,7 @@
 	Timestamp        uint64         `json:"timestamp"`
 	SequencerAddress *felt.Felt     `json:"sequencer_address,omitempty"`
 	L1GasPrice       *ResourcePrice `json:"l1_gas_price"`
-	L2GasPrice       *ResourcePrice `json:"l2_gas_price"`
+	L2GasPrice       *ResourcePrice `json:"l2_gas_price,omitempty"`
 	L1DataGasPrice   *ResourcePrice `json:"l1_data_gas_price,omitempty"`
 	L1DAMode         *L1DAMode      `json:"l1_da_mode,omitempty"`
 	StarknetVersion  string         `json:"starknet_version"`
@@ -171,6 +171,15 @@
 //
 // It follows the specification defined here:
 // https://github.com/starkware-libs/starknet-specs/blob/a789ccc3432c57777beceaa53a34a7ae2f25fda0/api/starknet_api_openrpc.json#L11
+func (h *Handler) BlockWithTxHashesV0_7(id BlockID) (*BlockWithTxHashes, *jsonrpc.Error) {
+	blockWithTxHashes, rpcErr := h.BlockWithTxHashes(id)
+	if rpcErr != nil {
+		return nil, rpcErr
+	}
+	blockWithTxHashes.L2GasPrice = nil
+	return blockWithTxHashes, nil
+}
+
 func (h *Handler) BlockWithTxHashes(id BlockID) (*BlockWithTxHashes, *jsonrpc.Error) {
 	block, rpcErr := h.blockByID(&id)
 	if rpcErr != nil {
@@ -194,6 +203,17 @@
 	}, 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.
 //
@@ -207,7 +227,20 @@
 	return header.TransactionCount, nil
 }
 
+func (h *Handler) BlockWithReceiptsV0_7(id BlockID) (*BlockWithReceipts, *jsonrpc.Error) {
+	blockWithReceipts, err := h.blockWithReceipts(id, V0_7)
+	if err != nil {
+		return nil, err
+	}
+	blockWithReceipts.L2GasPrice = nil
+	return blockWithReceipts, nil
+}
+
 func (h *Handler) BlockWithReceipts(id BlockID) (*BlockWithReceipts, *jsonrpc.Error) {
+	return h.blockWithReceipts(id, V0_8)
+}
+
+func (h *Handler) blockWithReceipts(id BlockID, rpcVersion version) (*BlockWithReceipts, *jsonrpc.Error) {
 	block, rpcErr := h.blockByID(&id)
 	if rpcErr != nil {
 		return nil, rpcErr
@@ -232,7 +265,7 @@
 		txsWithReceipts[index] = TransactionWithReceipt{
 			Transaction: t,
 			// block_hash, block_number are optional in BlockWithReceipts response
-			Receipt: AdaptReceipt(r, txn, finalityStatus, nil, 0),
+			Receipt: AdaptReceipt(r, txn, finalityStatus, nil, 0, rpcVersion),
 		}
 	}
 
@@ -247,6 +280,15 @@
 //
 // It follows the specification defined here:
 // https://github.com/starkware-libs/starknet-specs/blob/a789ccc3432c57777beceaa53a34a7ae2f25fda0/api/starknet_api_openrpc.json#L44
+func (h *Handler) BlockWithTxsV0_7(id BlockID) (*BlockWithTxs, *jsonrpc.Error) {
+	blockWithTxs, rpcErr := h.BlockWithTxs(id)
+	if rpcErr != nil {
+		return nil, rpcErr
+	}
+	blockWithTxs.L2GasPrice = nil
+	return blockWithTxs, nil
+}
+
 func (h *Handler) BlockWithTxs(id BlockID) (*BlockWithTxs, *jsonrpc.Error) {
 	block, rpcErr := h.blockByID(&id)
 	if rpcErr != nil {
@@ -270,6 +312,17 @@
 	}, 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 {

rpc/block_test.go

@@ -546,7 +546,78 @@ func TestBlockWithTxHashesV013(t *testing.T) {
 			Timestamp:        coreBlock.Timestamp,
 		},
 		Status: rpc.BlockAcceptedL2,
-		Transactions: []*rpc.Transaction{
+		Transactions: []*rpc.Transaction{ //nolint:dupl
+			{
+				Hash:               tx.Hash(),
+				Type:               rpc.TxnInvoke,
+				Version:            tx.Version.AsFelt(),
+				Nonce:              tx.Nonce,
+				MaxFee:             tx.MaxFee,
+				ContractAddress:    tx.ContractAddress,
+				SenderAddress:      tx.SenderAddress,
+				Signature:          &tx.TransactionSignature,
+				CallData:           &tx.CallData,
+				EntryPointSelector: tx.EntryPointSelector,
+				ResourceBounds: &map[rpc.Resource]rpc.ResourceBounds{
+					rpc.ResourceL1Gas: {
+						MaxAmount:       new(felt.Felt).SetUint64(tx.ResourceBounds[core.ResourceL1Gas].MaxAmount),
+						MaxPricePerUnit: tx.ResourceBounds[core.ResourceL1Gas].MaxPricePerUnit,
+					},
+					rpc.ResourceL2Gas: {
+						MaxAmount:       new(felt.Felt).SetUint64(tx.ResourceBounds[core.ResourceL2Gas].MaxAmount),
+						MaxPricePerUnit: tx.ResourceBounds[core.ResourceL2Gas].MaxPricePerUnit,
+					},
+				},
+				Tip:                   new(felt.Felt).SetUint64(tx.Tip),
+				PaymasterData:         &tx.PaymasterData,
+				AccountDeploymentData: &tx.AccountDeploymentData,
+				NonceDAMode:           utils.Ptr(rpc.DataAvailabilityMode(tx.NonceDAMode)),
+				FeeDAMode:             utils.Ptr(rpc.DataAvailabilityMode(tx.FeeDAMode)),
+			},
+		},
+	}, got)
+}
+
+func TestBlockWithTxHashesV013_V06(t *testing.T) {
+	n := utils.Ptr(utils.SepoliaIntegration)
+	mockCtrl := gomock.NewController(t)
+	t.Cleanup(mockCtrl.Finish)
+	mockReader := mocks.NewMockReader(mockCtrl)
+	handler := rpc.New(mockReader, nil, nil, "", nil)
+
+	blockNumber := uint64(16350)
+	gw := adaptfeeder.New(feeder.NewTestClient(t, n))
+	coreBlock, err := gw.BlockByNumber(context.Background(), blockNumber)
+	require.NoError(t, err)
+	tx, ok := coreBlock.Transactions[0].(*core.InvokeTransaction)
+	require.True(t, ok)
+
+	mockReader.EXPECT().BlockByNumber(gomock.Any()).Return(coreBlock, nil)
+	mockReader.EXPECT().L1Head().Return(&core.L1Head{}, nil)
+	got, rpcErr := handler.BlockWithTxsV0_6(rpc.BlockID{Number: blockNumber})
+	require.Nil(t, rpcErr)
+	got.Transactions = got.Transactions[:1]
+
+	require.Equal(t, &rpc.BlockWithTxs{
+		BlockHeader: rpc.BlockHeader{
+			Hash:            coreBlock.Hash,
+			StarknetVersion: coreBlock.ProtocolVersion,
+			NewRoot:         coreBlock.GlobalStateRoot,
+			Number:          &coreBlock.Number,
+			ParentHash:      coreBlock.ParentHash,
+			L1GasPrice: &rpc.ResourcePrice{
+				InFri: utils.HexToFelt(t, "0x17882b6aa74"),
+				InWei: utils.HexToFelt(t, "0x3b9aca10"),
+			},
+			L2GasPrice: &rpc.ResourcePrice{
+				InFri: &felt.Zero,
+				InWei: &felt.Zero,
+			},
+			SequencerAddress: coreBlock.SequencerAddress,
+			Timestamp:        coreBlock.Timestamp,
+		},
+		Status: rpc.BlockAcceptedL2,
+		Transactions: []*rpc.Transaction{ //nolint:dupl
 			{
 				Hash:               tx.Hash(),
 				Type:               rpc.TxnInvoke,
@@ -632,7 +703,7 @@ func TestBlockWithReceipts(t *testing.T) {
 
 			txsWithReceipt = append(txsWithReceipt, rpc.TransactionWithReceipt{
 				Transaction: adaptedTx,
-				Receipt:     rpc.AdaptReceipt(receipt, tx, rpc.TxnAcceptedOnL2, nil, 0),
+				Receipt:     rpc.AdaptReceipt(receipt, tx, rpc.TxnAcceptedOnL2, nil, 0, rpc.V0_8),
 			})
 		}
 
@@ -678,7 +749,7 @@ func TestBlockWithReceipts(t *testing.T) {
 
 			transactions = append(transactions, rpc.TransactionWithReceipt{
 				Transaction: adaptedTx,
-				Receipt:     rpc.AdaptReceipt(receipt, tx, rpc.TxnAcceptedOnL1, nil, 0),
+				Receipt:     rpc.AdaptReceipt(receipt, tx, rpc.TxnAcceptedOnL1, nil, 0, rpc.V0_8),
 			})
 		}