Avoid type conversion in json registerValidator cache check (#729)

* trying faster json parsing by avoiding type conversion before cache check

* simplify code a bit

We can parse most of the types, except pubkey and signature without any performance issues. This way we do not need to store second form in local cache

---------

Co-authored-by: Ilya Lukyanov <[email protected]>

Author: metachris

.claudeignore

@@ -0,0 +1,4 @@
+.github/
+/scripts/
+/static/
+/docs/

common/errors.go

@@ -7,4 +7,8 @@ var (
 	ErrInvalidHash      = errors.New("invalid hash")
 	ErrInvalidPubkey    = errors.New("invalid pubkey")
 	ErrInvalidSignature = errors.New("invalid signature")
+
+	ErrTimestampNegative       = errors.New("timestamp is negative")
+	ErrTimestampTooEarly       = errors.New("timestamp too early")
+	ErrTimestampTooFarInFuture = errors.New("timestamp too far in the future")
 )

common/types.go

@@ -7,15 +7,18 @@ import (
 	"os"
 	"strconv"
 	"strings"
+	"time"
 
 	builderApiV1 "github.com/attestantio/go-builder-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/bellatrix"
 	"github.com/attestantio/go-eth2-client/spec/capella"
 	"github.com/attestantio/go-eth2-client/spec/deneb"
 	"github.com/attestantio/go-eth2-client/spec/electra"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/buger/jsonparser"
 	ssz "github.com/ferranbt/fastssz"
 	boostSsz "github.com/flashbots/go-boost-utils/ssz"
+	"github.com/flashbots/go-boost-utils/utils"
 )
 
 var (
@@ -218,6 +221,8 @@ func (e *EthNetworkDetails) String() string {
 		e.DomainBeaconProposerElectra)
 }
 
+// PubkeyHex represents a hex-encoded public key.
+// It is lowercased on creation and is not validated/parsed.
 type PubkeyHex string
 
 func NewPubkeyHex(pk string) PubkeyHex {
@@ -228,6 +233,10 @@ func (p PubkeyHex) String() string {
 	return string(p)
 }
 
+func (p PubkeyHex) ToPubkey() (ret phase0.BLSPubKey, err error) {
+	return utils.HexToPubkey(string(p))
+}
+
 type BuilderGetValidatorsResponseEntry struct {
 	Slot           uint64                                    `json:"slot,string"`
 	ValidatorIndex uint64                                    `json:"validator_index,string"`
@@ -728,3 +737,68 @@ func (s *SubmitBlockRequestV2Optimistic) SizeSSZ() (size int) {
 
 	return
 }
+
+// SimpleValidatorRegistration is a helper type for fast JSON decoding
+type SimpleValidatorRegistration struct {
+	FeeRecipient bellatrix.ExecutionAddress
+	GasLimit     uint64
+	Timestamp    time.Time
+
+	// These two are intentionally left unparsed due to heavy parsing maths
+	Pubkey    PubkeyHex
+	Signature string
+}
+
+func (r *SimpleValidatorRegistration) UnmarshalJSON(value []byte) error {
+	_feeRecipient, err := jsonparser.GetUnsafeString(value, "message", "fee_recipient")
+	if err != nil {
+		return fmt.Errorf("registration message error (fee_recipient): %w", err)
+	}
+
+	// this one is fast, it's hex decode, no fancy crypto maths
+	feeRecipient, err := utils.HexToAddress(_feeRecipient)
+	if err != nil {
+		return fmt.Errorf("registration message error (fee_recipient): %w", err)
+	}
+
+	_gasLimit, err := jsonparser.GetUnsafeString(value, "message", "gas_limit")
+	if err != nil {
+		return fmt.Errorf("registration message error (gasLimit): %w", err)
+	}
+
+	gasLimit, err := strconv.ParseUint(_gasLimit, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid gasLimit: %w", err)
+	}
+
+	_timestamp, err := jsonparser.GetUnsafeString(value, "message", "timestamp")
+	if err != nil {
+		return fmt.Errorf("registration message error (timestamp): %w", err)
+	}
+
+	timestamp, err := strconv.ParseInt(_timestamp, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid timestamp: %w", err)
+	}
+	if timestamp < 0 {
+		return ErrTimestampNegative
+	}
+
+	pubkey, err := jsonparser.GetUnsafeString(value, "message", "pubkey")
+	if err != nil {
+		return fmt.Errorf("registration message error (pubkey): %w", err)
+	}
+
+	signature, err := jsonparser.GetUnsafeString(value, "signature")
+	if err != nil {
+		return fmt.Errorf("registration message error (signature): %w", err)
+	}
+
+	r.FeeRecipient = feeRecipient
+	r.GasLimit = gasLimit
+	r.Timestamp = time.Unix(timestamp, 0)
+	r.Pubkey = NewPubkeyHex(pubkey)
+	r.Signature = signature
+
+	return nil
+}

datastore/redis.go

@@ -242,9 +242,9 @@ func (r *RedisCache) HSetObj(key, field string, value any, expiration time.Durat
 
 func (r *RedisCache) GetValidatorRegistrationData(proposerPubkey common.PubkeyHex) (*builderApiV1.ValidatorRegistration, error) {
 	data := new(builderApiV1.ValidatorRegistration)
-	pk := strings.ToLower(proposerPubkey.String())
 
-	dataRaw, err := r.client.HGet(context.Background(), r.keyValidatorRegistrationData, pk).Result()
+	// common.PubkeyHex is lowercase at the time of creation
+	dataRaw, err := r.client.HGet(context.Background(), r.keyValidatorRegistrationData, proposerPubkey.String()).Result()
 	if errors.Is(err, redis.Nil) {
 		return nil, nil
 	}