Cherry-Pick: Added pending enpoints (#16233)

Author: Giulio2002

cl/beacon/handler/handler.go

@@ -299,6 +299,9 @@ func (a *ApiHandler) init() {
 							r.Post("/validator_balances", a.PostEthV1BeaconValidatorsBalances)
 							r.Get("/validators/{validator_id}", beaconhttp.HandleEndpointFunc(a.GetEthV1BeaconStatesValidator))
 							r.Get("/validator_identities", beaconhttp.HandleEndpointFunc(a.GetEthV1ValidatorIdentities))
+							r.Get("/pending_consolidations", beaconhttp.HandleEndpointFunc(a.GetEthV1BeaconStatesPendingConsolidations))
+							r.Get("/pending_deposits", beaconhttp.HandleEndpointFunc(a.GetEthV1BeaconStatesPendingDeposits))
+							r.Get("/pending_partial_withdrawals", beaconhttp.HandleEndpointFunc(a.GetEthV1BeaconStatesPendingPartialWithdrawals))
 						})
 					})
 				})

cl/beacon/handler/states.go

@@ -31,6 +31,7 @@ import (
 	"github.com/erigontech/erigon/cl/cltypes/solid"
 	"github.com/erigontech/erigon/cl/persistence/beacon_indicies"
 	state_accessors "github.com/erigontech/erigon/cl/persistence/state"
+	"github.com/erigontech/erigon/cl/persistence/state/historical_states_reader"
 	"github.com/erigontech/erigon/cl/utils"
 )
 
@@ -451,3 +452,178 @@ func (a *ApiHandler) getRandao(w http.ResponseWriter, r *http.Request) (*beaconh
 		WithFinalized(slot <= a.forkchoiceStore.FinalizedSlot()).
 		WithOptimistic(isOptimistic), nil
 }
+
+// Implements /eth/v1/beacon/states/{state_id}/pending_consolidations
+func (a *ApiHandler) GetEthV1BeaconStatesPendingConsolidations(w http.ResponseWriter, r *http.Request) (*beaconhttp.BeaconResponse, error) {
+	ctx := r.Context()
+
+	tx, err := a.indiciesDB.BeginRo(ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+
+	blockId, err := beaconhttp.StateIdFromRequest(r)
+	if err != nil {
+		return nil, beaconhttp.NewEndpointError(http.StatusBadRequest, err)
+	}
+
+	blockRoot, httpStatus, err := a.blockRootFromStateId(ctx, tx, blockId)
+	if err != nil {
+		return nil, beaconhttp.NewEndpointError(httpStatus, err)
+	}
+
+	isOptimistic := a.forkchoiceStore.IsRootOptimistic(blockRoot)
+	slot, err := beacon_indicies.ReadBlockSlotByBlockRoot(tx, blockRoot)
+	if err != nil {
+		return nil, err
+	}
+	if slot == nil {
+		return nil, beaconhttp.NewEndpointError(http.StatusNotFound, fmt.Errorf("could not read block slot: %x", blockRoot))
+	}
+
+	canonicalRoot, err := beacon_indicies.ReadCanonicalBlockRoot(tx, *slot)
+	if err != nil {
+		return nil, err
+	}
+
+	pendingConsolidations := solid.NewPendingConsolidationList(a.beaconChainCfg)
+
+	isSlotAvailableInMemory := a.forkchoiceStore.LowestAvailableSlot() < *slot
+
+	if isSlotAvailableInMemory {
+		var ok bool
+		pendingConsolidations, ok = a.forkchoiceStore.GetPendingConsolidations(blockRoot)
+		if !ok {
+			return nil, beaconhttp.NewEndpointError(http.StatusNotFound, fmt.Errorf("no pending	 consolidations found for block root: %x", blockRoot))
+		}
+		// If we have the pending consolidations in memory, we can return them directly.
+	} else {
+		stateView := a.caplinStateSnapshots.View()
+		defer stateView.Close()
+
+		if err := historical_states_reader.ReadQueueSSZ(state_accessors.GetValFnTxAndSnapshot(tx, stateView), *slot, kv.PendingConsolidationsDump, kv.PendingConsolidations, pendingConsolidations); err != nil {
+			return nil, beaconhttp.NewEndpointError(http.StatusInternalServerError, fmt.Errorf("failed to read pending consolidations: %w", err))
+		}
+	}
+
+	return newBeaconResponse(pendingConsolidations).
+		WithOptimistic(isOptimistic).
+		WithFinalized(canonicalRoot == blockRoot && *slot <= a.forkchoiceStore.FinalizedSlot()), nil
+}
+
+// Implements /eth/v1/beacon/states/{state_id}/pending_deposits
+func (a *ApiHandler) GetEthV1BeaconStatesPendingDeposits(w http.ResponseWriter, r *http.Request) (*beaconhttp.BeaconResponse, error) {
+	ctx := r.Context()
+
+	tx, err := a.indiciesDB.BeginRo(ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+
+	blockId, err := beaconhttp.StateIdFromRequest(r)
+	if err != nil {
+		return nil, beaconhttp.NewEndpointError(http.StatusBadRequest, err)
+	}
+
+	blockRoot, httpStatus, err := a.blockRootFromStateId(ctx, tx, blockId)
+	if err != nil {
+		return nil, beaconhttp.NewEndpointError(httpStatus, err)
+	}
+
+	isOptimistic := a.forkchoiceStore.IsRootOptimistic(blockRoot)
+	slot, err := beacon_indicies.ReadBlockSlotByBlockRoot(tx, blockRoot)
+	if err != nil {
+		return nil, err
+	}
+	if slot == nil {
+		return nil, beaconhttp.NewEndpointError(http.StatusNotFound, fmt.Errorf("could not read block slot: %x", blockRoot))
+	}
+
+	canonicalRoot, err := beacon_indicies.ReadCanonicalBlockRoot(tx, *slot)
+	if err != nil {
+		return nil, err
+	}
+
+	pendingDeposits := solid.NewPendingDepositList(a.beaconChainCfg)
+
+	isSlotAvailableInMemory := a.forkchoiceStore.LowestAvailableSlot() < *slot
+
+	if isSlotAvailableInMemory {
+		var ok bool
+		pendingDeposits, ok = a.forkchoiceStore.GetPendingDeposits(blockRoot)
+		if !ok {
+			return nil, beaconhttp.NewEndpointError(http.StatusNotFound, fmt.Errorf("no pending	 deposits found for block root: %x", blockRoot))
+		}
+	} else {
+		stateView := a.caplinStateSnapshots.View()
+		defer stateView.Close()
+
+		if err := historical_states_reader.ReadQueueSSZ(state_accessors.GetValFnTxAndSnapshot(tx, stateView), *slot, kv.PendingDepositsDump, kv.PendingDeposits, pendingDeposits); err != nil {
+			return nil, beaconhttp.NewEndpointError(http.StatusInternalServerError, fmt.Errorf("failed to read pending deposits: %w", err))
+		}
+	}
+
+	return newBeaconResponse(pendingDeposits).
+		WithOptimistic(isOptimistic).
+		WithFinalized(canonicalRoot == blockRoot && *slot <= a.forkchoiceStore.FinalizedSlot()), nil
+}
+
+// Implements /eth/v1/beacon/states/{state_id}/pending_partial_withdrawals
+func (a *ApiHandler) GetEthV1BeaconStatesPendingPartialWithdrawals(w http.ResponseWriter, r *http.Request) (*beaconhttp.BeaconResponse, error) {
+	ctx := r.Context()
+
+	tx, err := a.indiciesDB.BeginRo(ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+
+	blockId, err := beaconhttp.StateIdFromRequest(r)
+	if err != nil {
+		return nil, beaconhttp.NewEndpointError(http.StatusBadRequest, err)
+	}
+
+	blockRoot, httpStatus, err := a.blockRootFromStateId(ctx, tx, blockId)
+	if err != nil {
+		return nil, beaconhttp.NewEndpointError(httpStatus, err)
+	}
+
+	isOptimistic := a.forkchoiceStore.IsRootOptimistic(blockRoot)
+	slot, err := beacon_indicies.ReadBlockSlotByBlockRoot(tx, blockRoot)
+	if err != nil {
+		return nil, err
+	}
+	if slot == nil {
+		return nil, beaconhttp.NewEndpointError(http.StatusNotFound, fmt.Errorf("could not read block slot: %x", blockRoot))
+	}
+
+	canonicalRoot, err := beacon_indicies.ReadCanonicalBlockRoot(tx, *slot)
+	if err != nil {
+		return nil, err
+	}
+
+	pendingWithdrawals := solid.NewPendingWithdrawalList(a.beaconChainCfg)
+
+	isSlotAvailableInMemory := a.forkchoiceStore.LowestAvailableSlot() < *slot
+
+	if isSlotAvailableInMemory {
+		var ok bool
+		pendingWithdrawals, ok = a.forkchoiceStore.GetPendingPartialWithdrawals(blockRoot)
+		if !ok {
+			return nil, beaconhttp.NewEndpointError(http.StatusNotFound, fmt.Errorf("no pending partial withdrawals found for block root: %x", blockRoot))
+		}
+	} else {
+		stateView := a.caplinStateSnapshots.View()
+		defer stateView.Close()
+
+		if err := historical_states_reader.ReadQueueSSZ(state_accessors.GetValFnTxAndSnapshot(tx, stateView), *slot, kv.PendingPartialWithdrawalsDump, kv.PendingPartialWithdrawals, pendingWithdrawals); err != nil {
+			return nil, beaconhttp.NewEndpointError(http.StatusInternalServerError, fmt.Errorf("failed to read pending partial withdrawals: %w", err))
+		}
+	}
+
+	return newBeaconResponse(pendingWithdrawals).
+		WithOptimistic(isOptimistic).
+		WithFinalized(canonicalRoot == blockRoot && *slot <= a.forkchoiceStore.FinalizedSlot()), nil
+}

cl/cltypes/solid/consolidation.go

@@ -53,8 +53,8 @@ func (p *ConsolidationRequest) Static() bool {
 }
 
 type PendingConsolidation struct {
-	SourceIndex uint64 // validator index
-	TargetIndex uint64 // validator index
+	SourceIndex uint64 `json:"source_index"` // validator index
+	TargetIndex uint64 `json:"target_index"` // validator index
 }
 
 func (p *PendingConsolidation) EncodingSizeSSZ() int {

cl/cltypes/solid/deposits.go

@@ -55,11 +55,11 @@ func (p *DepositRequest) Static() bool {
 }
 
 type PendingDeposit struct {
-	PubKey                common.Bytes48 // BLS public key
-	WithdrawalCredentials common.Hash
-	Amount                uint64         // Gwei
-	Signature             common.Bytes96 // BLS signature
-	Slot                  uint64
+	PubKey                common.Bytes48 `json:"pubkey"` // BLS public key
+	WithdrawalCredentials common.Hash    `json:"withdrawal_credentials"`
+	Amount                uint64         `json:"amount"`    // Gwei
+	Signature             common.Bytes96 `json:"signature"` // BLS signature
+	Slot                  uint64         `json:"slot"`
 }
 
 func (p *PendingDeposit) EncodingSizeSSZ() int {

cl/cltypes/solid/withdrawal.go

@@ -53,9 +53,9 @@ func (p *WithdrawalRequest) Static() bool {
 }
 
 type PendingPartialWithdrawal struct {
-	Index             uint64 // validator index
-	Amount            uint64 // Gwei
-	WithdrawableEpoch uint64
+	Index             uint64 `json:"index"`              // validator index
+	Amount            uint64 `json:"amount"`             // Gwei
+	WithdrawableEpoch uint64 `json:"withdrawable_epoch"` // epoch when the withdrawal can be processed
 }
 
 func (p *PendingPartialWithdrawal) EncodingSizeSSZ() int {

cl/persistence/state/historical_states_reader/historical_states_reader.go

@@ -308,15 +308,15 @@ func (r *HistoricalStatesReader) ReadHistoricalState(ctx context.Context, tx kv.
 		pendingWithdrawals    = solid.NewPendingWithdrawalList(r.cfg)
 	)
 
-	if err := readQueueSSZ(kvGetter, slot, kv.PendingConsolidationsDump, kv.PendingConsolidations, pendingConsolidations); err != nil {
+	if err := ReadQueueSSZ(kvGetter, slot, kv.PendingConsolidationsDump, kv.PendingConsolidations, pendingConsolidations); err != nil {
 		return nil, fmt.Errorf("failed to read pending consolidations: %w", err)
 	}
 
-	if err := readQueueSSZ(kvGetter, slot, kv.PendingDepositsDump, kv.PendingDeposits, pendingDeposits); err != nil {
+	if err := ReadQueueSSZ(kvGetter, slot, kv.PendingDepositsDump, kv.PendingDeposits, pendingDeposits); err != nil {
 		return nil, fmt.Errorf("failed to read pending deposits: %w", err)
 	}
 
-	if err := readQueueSSZ(kvGetter, slot, kv.PendingPartialWithdrawalsDump, kv.PendingPartialWithdrawals, pendingWithdrawals); err != nil {
+	if err := ReadQueueSSZ(kvGetter, slot, kv.PendingPartialWithdrawalsDump, kv.PendingPartialWithdrawals, pendingWithdrawals); err != nil {
 		return nil, fmt.Errorf("failed to read pending withdrawals: %w", err)
 	}
 
@@ -983,7 +983,7 @@ func (r *HistoricalStatesReader) ReadRandaoMixBySlotAndIndex(tx kv.Tx, kvGetter
 	return common.BytesToHash(mixBytes), nil
 }
 
-func readQueueSSZ[T solid.EncodableHashableSSZ](kvGetter state_accessors.GetValFn, slot uint64, dumpTable, diffsTable string, out *solid.ListSSZ[T]) error {
+func ReadQueueSSZ[T solid.EncodableHashableSSZ](kvGetter state_accessors.GetValFn, slot uint64, dumpTable, diffsTable string, out *solid.ListSSZ[T]) error {
 	remainder := slot % clparams.SlotsPerDump
 	freshDumpSlot := slot - remainder