internal/restapi: implement trustless REST API (WIP)

beacon/blsync/server.go

@@ -0,0 +1,25 @@
+// Copyright 2025 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package blsync
+
+import (
+	"net/http"
+)
+
+func (c *Client) NewAPIServer() func(mux *http.ServeMux, maxResponseSize int) {
+	return func(mux *http.ServeMux, maxResponseSize int) {}
+}

cmd/clef/main.go

@@ -737,7 +737,7 @@ func signer(c *cli.Context) error {
 
 		srv := rpc.NewServer()
 		srv.SetBatchLimits(node.DefaultConfig.BatchRequestLimit, node.DefaultConfig.BatchResponseMaxSize)
-		err := node.RegisterApis(rpcAPI, []string{"account"}, srv)
+		err := node.RegisterRpcAPIs(rpcAPI, []string{"account"}, srv)
 		if err != nil {
 			utils.Fatalf("Could not register API: %w", err)
 		}

cmd/geth/config.go

@@ -300,6 +300,9 @@ func makeFullNode(ctx *cli.Context) *node.Node {
 		srv.RegisterName("engine", catalyst.NewConsensusAPI(eth))
 		blsyncer := blsync.NewClient(utils.MakeBeaconLightConfig(ctx))
 		blsyncer.SetEngineRPC(rpc.DialInProc(srv))
+		if eth != nil {
+			eth.Blsync = blsyncer
+		}
 		stack.RegisterLifecycle(blsyncer)
 	} else {
 		// Launch the engine API for interacting with external consensus client.

cmd/utils/flags.go

@@ -2017,7 +2017,7 @@ func RegisterEthService(stack *node.Node, cfg *ethconfig.Config) (*eth.EthAPIBac
 	if err != nil {
 		Fatalf("Failed to register the Ethereum service: %v", err)
 	}
-	stack.RegisterAPIs(tracers.APIs(backend.APIBackend))
+	stack.RegisterRpcAPIs(tracers.APIs(backend.APIBackend))
 	return backend.APIBackend, backend
 }
 
@@ -2042,7 +2042,7 @@ func RegisterFilterAPI(stack *node.Node, backend ethapi.Backend, ethcfg *ethconf
 		LogCacheSize:  ethcfg.FilterLogCacheSize,
 		LogQueryLimit: ethcfg.LogQueryLimit,
 	})
-	stack.RegisterAPIs([]rpc.API{{
+	stack.RegisterRpcAPIs([]rpc.API{{
 		Namespace: "eth",
 		Service:   filters.NewFilterAPI(filterSystem),
 	}})

eth/api_backend.go

@@ -24,6 +24,7 @@ import (
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts"
+	"github.com/ethereum/go-ethereum/beacon/blsync"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
@@ -431,6 +432,10 @@ func (b *EthAPIBackend) BlobBaseFee(ctx context.Context) *big.Int {
 	return nil
 }
 
+func (b *EthAPIBackend) Blsync() *blsync.Client {
+	return b.eth.Blsync
+}
+
 func (b *EthAPIBackend) ChainDb() ethdb.Database {
 	return b.eth.ChainDb()
 }

eth/backend.go

@@ -28,6 +28,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/accounts"
+	"github.com/ethereum/go-ethereum/beacon/blsync"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/consensus"
@@ -50,6 +51,7 @@ import (
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/internal/ethapi"
+	"github.com/ethereum/go-ethereum/internal/restapi"
 	"github.com/ethereum/go-ethereum/internal/shutdowncheck"
 	"github.com/ethereum/go-ethereum/internal/version"
 	"github.com/ethereum/go-ethereum/log"
@@ -59,6 +61,7 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/dnsdisc"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rest"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/rpc"
 	gethversion "github.com/ethereum/go-ethereum/version"
@@ -113,6 +116,8 @@ type Ethereum struct {
 
 	APIBackend *EthAPIBackend
 
+	Blsync *blsync.Client
+
 	miner    *miner.Miner
 	gasPrice *big.Int
 
@@ -346,7 +351,11 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 	eth.miner.SetExtra(makeExtraData(config.Miner.ExtraData))
 	eth.miner.SetPrioAddresses(config.TxPool.Locals)
 
-	eth.APIBackend = &EthAPIBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, eth, nil}
+	eth.APIBackend = &EthAPIBackend{
+		extRPCEnabled:       stack.Config().ExtRPCEnabled(),
+		allowUnprotectedTxs: stack.Config().AllowUnprotectedTxs,
+		eth:                 eth,
+	}
 	if eth.APIBackend.allowUnprotectedTxs {
 		log.Info("Unprotected transactions allowed")
 	}
@@ -356,7 +365,8 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 	eth.netRPCService = ethapi.NewNetAPI(eth.p2pServer, networkID)
 
 	// Register the backend on the node
-	stack.RegisterAPIs(eth.APIs())
+	stack.RegisterRpcAPIs(eth.RpcAPIs())
+	stack.RegisterRestAPIs(eth.RestAPIs())
 	stack.RegisterProtocols(eth.Protocols())
 	stack.RegisterLifecycle(eth)
 
@@ -383,9 +393,9 @@ func makeExtraData(extra []byte) []byte {
 	return extra
 }
 
-// APIs return the collection of RPC services the ethereum package offers.
+// RpcAPIs return the collection of RPC services the ethereum package offers.
 // NOTE, some of these services probably need to be moved to somewhere else.
-func (s *Ethereum) APIs() []rpc.API {
+func (s *Ethereum) RpcAPIs() []rpc.API {
 	apis := ethapi.GetAPIs(s.APIBackend)
 
 	// Append all the local APIs and return
@@ -409,6 +419,11 @@ func (s *Ethereum) APIs() []rpc.API {
 	}...)
 }
 
+// RestAPIs return the collection of REST API services the ethereum package offers.
+func (s *Ethereum) RestAPIs() []rest.API {
+	return restapi.GetAPIs(s.APIBackend)
+}
+
 func (s *Ethereum) ResetWithGenesisBlock(gb *types.Block) {
 	s.blockchain.ResetWithGenesisBlock(gb)
 }

eth/catalyst/api.go

@@ -48,7 +48,7 @@ import (
 // Register adds the engine API to the full node.
 func Register(stack *node.Node, backend *eth.Ethereum) error {
 	log.Warn("Engine API enabled", "protocol", "eth")
-	stack.RegisterAPIs([]rpc.API{
+	stack.RegisterRpcAPIs([]rpc.API{
 		{
 			Namespace:     "engine",
 			Service:       NewConsensusAPI(backend),

eth/catalyst/simulated_beacon.go

@@ -359,7 +359,7 @@ func (c *SimulatedBeacon) AdjustTime(adjustment time.Duration) error {
 // stack.
 func RegisterSimulatedBeaconAPIs(stack *node.Node, sim *SimulatedBeacon) {
 	api := newSimulatedBeaconAPI(sim)
-	stack.RegisterAPIs([]rpc.API{
+	stack.RegisterRpcAPIs([]rpc.API{
 		{
 			Namespace: "dev",
 			Service:   api,

eth/syncer/syncer.go

@@ -63,7 +63,7 @@ func Register(stack *node.Node, backend *eth.Ethereum, target common.Hash, exitW
 		closed:         make(chan struct{}),
 		exitWhenSynced: exitWhenSynced,
 	}
-	stack.RegisterAPIs(s.APIs())
+	stack.RegisterRpcAPIs(s.APIs())
 	stack.RegisterLifecycle(s)
 	return s, nil
 }

ethclient/gethclient/gethclient_test.go

@@ -66,10 +66,10 @@ func newTestBackend(t *testing.T) (*node.Node, []*types.Block, []common.Hash) {
 	if err != nil {
 		t.Fatalf("can't create new ethereum service: %v", err)
 	}
-	n.RegisterAPIs(tracers.APIs(ethservice.APIBackend))
+	n.RegisterRpcAPIs(tracers.APIs(ethservice.APIBackend))
 
 	filterSystem := filters.NewFilterSystem(ethservice.APIBackend, filters.Config{})
-	n.RegisterAPIs([]rpc.API{{
+	n.RegisterRpcAPIs([]rpc.API{{
 		Namespace: "eth",
 		Service:   filters.NewFilterAPI(filterSystem),
 	}})

ethclient/simulated/backend.go

@@ -111,7 +111,7 @@ func newWithNode(stack *node.Node, conf *eth.Config, blockPeriod uint64) (*Backe
 	}
 	// Register the filter system
 	filterSystem := filters.NewFilterSystem(backend.APIBackend, filters.Config{})
-	stack.RegisterAPIs([]rpc.API{{
+	stack.RegisterRpcAPIs([]rpc.API{{
 		Namespace: "eth",
 		Service:   filters.NewFilterAPI(filterSystem),
 	}})

internal/restapi/backend.go

@@ -0,0 +1,51 @@
+// Copyright 2025 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package restapi
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/beacon/blsync"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rest"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+type Backend interface {
+	HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error)
+	HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error)
+	ChainConfig() *params.ChainConfig
+	Blsync() *blsync.Client
+}
+
+func GetAPIs(apiBackend Backend) []rest.API {
+	apis := []rest.API{
+		{
+			Namespace: "exec",
+			Register:  NewExecutionRestAPI(apiBackend),
+		},
+	}
+	if apiBackend.Blsync() != nil {
+		apis = append(apis, rest.API{
+			Namespace: "beacon",
+			Register:  apiBackend.Blsync().NewAPIServer(),
+		})
+	}
+	return apis
+}