init commit optimistic relay

common/common.go

@@ -21,3 +21,12 @@ type HTTPServerTimeouts struct {
 	Write      time.Duration // Timeout for writes. None if 0.
 	Idle       time.Duration // Timeout to disconnect idle client connections. None if 0.
 }
+
+type BlockBuilderStatusCode uint8
+
+const (
+	LowPrio BlockBuilderStatusCode = iota
+	HighPrio
+	Optimistic
+	Blacklisted
+)

database/database.go

@@ -41,9 +41,11 @@ type IDatabaseService interface {
 
 	GetBlockBuilders() ([]*BlockBuilderEntry, error)
 	GetBlockBuilderByPubkey(pubkey string) (*BlockBuilderEntry, error)
-	SetBlockBuilderStatus(pubkey string, isHighPrio, isBlacklisted bool) error
+	SetBlockBuilderStatus(pubkey string, status common.BlockBuilderStatusCode) error
 	UpsertBlockBuilderEntryAfterSubmission(lastSubmission *BuilderBlockSubmissionEntry, isError bool) error
 	IncBlockBuilderStatsAfterGetPayload(builderPubkey string) error
+
+	SaveValidatorRefund(bidTrace *common.BidTraceV2, signedBlindedBeaconBlock *types.SignedBlindedBeaconBlock) error
 }
 
 type DatabaseService struct {
@@ -436,8 +438,8 @@ func (s *DatabaseService) UpsertBlockBuilderEntryAfterSubmission(lastSubmission
 
 	// Upsert
 	query := `INSERT INTO ` + vars.TableBlockBuilder + `
-		(builder_pubkey, description, is_high_prio, is_blacklisted, last_submission_id, last_submission_slot, num_submissions_total, num_submissions_simerror) VALUES
-		(:builder_pubkey, :description, :is_high_prio, :is_blacklisted, :last_submission_id, :last_submission_slot, :num_submissions_total, :num_submissions_simerror)
+		(builder_pubkey, description, builder_status, last_submission_id, last_submission_slot, num_submissions_total, num_submissions_simerror) VALUES
+		(:builder_pubkey, :description, :builder_status, :last_submission_id, :last_submission_slot, :num_submissions_total, :num_submissions_simerror)
 		ON CONFLICT (builder_pubkey) DO UPDATE SET
 			last_submission_id = :last_submission_id,
 			last_submission_slot = :last_submission_slot,
@@ -448,22 +450,22 @@ func (s *DatabaseService) UpsertBlockBuilderEntryAfterSubmission(lastSubmission
 }
 
 func (s *DatabaseService) GetBlockBuilders() ([]*BlockBuilderEntry, error) {
-	query := `SELECT id, inserted_at, builder_pubkey, description, is_high_prio, is_blacklisted, last_submission_id, last_submission_slot, num_submissions_total, num_submissions_simerror, num_sent_getpayload FROM ` + vars.TableBlockBuilder + ` ORDER BY id ASC;`
+	query := `SELECT id, inserted_at, builder_pubkey, description, builder_status, last_submission_id, last_submission_slot, num_submissions_total, num_submissions_simerror, num_sent_getpayload FROM ` + vars.TableBlockBuilder + ` ORDER BY id ASC;`
 	entries := []*BlockBuilderEntry{}
 	err := s.DB.Select(&entries, query)
 	return entries, err
 }
 
 func (s *DatabaseService) GetBlockBuilderByPubkey(pubkey string) (*BlockBuilderEntry, error) {
-	query := `SELECT id, inserted_at, builder_pubkey, description, is_high_prio, is_blacklisted, last_submission_id, last_submission_slot, num_submissions_total, num_submissions_simerror, num_sent_getpayload FROM ` + vars.TableBlockBuilder + ` WHERE builder_pubkey=$1;`
+	query := `SELECT id, inserted_at, builder_pubkey, description, builder_status, last_submission_id, last_submission_slot, num_submissions_total, num_submissions_simerror, num_sent_getpayload FROM ` + vars.TableBlockBuilder + ` WHERE builder_pubkey=$1;`
 	entry := &BlockBuilderEntry{}
 	err := s.DB.Get(entry, query, pubkey)
 	return entry, err
 }
 
-func (s *DatabaseService) SetBlockBuilderStatus(pubkey string, isHighPrio, isBlacklisted bool) error {
-	query := `UPDATE ` + vars.TableBlockBuilder + ` SET is_high_prio=$1, is_blacklisted=$2 WHERE builder_pubkey=$3;`
-	_, err := s.DB.Exec(query, isHighPrio, isBlacklisted, pubkey)
+func (s *DatabaseService) SetBlockBuilderStatus(pubkey string, builderStatus common.BlockBuilderStatusCode) error {
+	query := `UPDATE ` + vars.TableBlockBuilder + ` SET builder_status=$1 WHERE builder_pubkey=$3;`
+	_, err := s.DB.Exec(query, uint8(builderStatus), pubkey)
 	return err
 }
 
@@ -486,3 +488,29 @@ func (s *DatabaseService) DeleteExecutionPayloads(idFirst, idLast uint64) error
 	_, err := s.DB.Exec(query, idFirst, idLast)
 	return err
 }
+
+func (s *DatabaseService) SaveValidatorRefund(bidTrace *common.BidTraceV2, signedBlindedBeaconBlock *types.SignedBlindedBeaconBlock) error {
+	_signedBlindedBeaconBlock, err := json.Marshal(signedBlindedBeaconBlock)
+	if err != nil {
+		return err
+	}
+
+	validatorRefundEntry := ValidatorRefundEntry{
+		SignedBlindedBeaconBlock: NewNullString(string(_signedBlindedBeaconBlock)),
+
+		Slot:  bidTrace.Slot,
+		Epoch: bidTrace.Slot / uint64(common.SlotsPerEpoch),
+
+		BuilderPubkey:  bidTrace.BuilderPubkey.String(),
+		ProposerPubkey: bidTrace.ProposerPubkey.String(),
+
+		Value: bidTrace.Value.String(),
+	}
+
+	query := `INSERT INTO ` + vars.TableValidatorRefunds + `
+		(signed_blinded_beacon_block, slot, epoch, builder_pubkey, proposer_pubkey, value) VALUES
+		(:signed_blinded_beacon_block, :slot, :epoch, :builder_pubkey, :proposer_pubkey, :value)
+		ON CONFLICT DO NOTHING`
+	_, err = s.DB.NamedExec(query, validatorRefundEntry)
+	return err
+}

database/migrations/001_init_database.go

@@ -120,8 +120,7 @@ var Migration001InitDatabase = &migrate.Migration{
 			builder_pubkey  varchar(98) NOT NULL,
 			description    	text NOT NULL,
 
-			is_high_prio    boolean NOT NULL,
-			is_blacklisted  boolean NOT NULL,
+			builder_status  bigint NOT NULL,
 
 			last_submission_id   bigint references ` + vars.TableBuilderBlockSubmission + `(id) on delete set null,
 			last_submission_slot bigint NOT NULL,
@@ -134,6 +133,21 @@ var Migration001InitDatabase = &migrate.Migration{
 
 			UNIQUE (builder_pubkey)
 		);
+
+		CREATE TABLE IF NOT EXISTS ` + vars.TableValidatorRefunds + `(
+			id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+			inserted_at timestamp NOT NULL default current_timestamp,
+
+			signed_blinded_beacon_block json,
+
+			epoch bigint NOT NULL,
+			slot  bigint NOT NULL,
+
+			builder_pubkey         varchar(98) NOT NULL,
+			proposer_pubkey        varchar(98) NOT NULL,
+
+			value   NUMERIC(48, 0),
+		);
 		`},
 	Down: []string{`
 		DROP TABLE IF EXISTS ` + vars.TableBuilderBlockSubmission + `;

database/mockdb.go

@@ -89,7 +89,7 @@ func (db MockDB) GetBlockBuilderByPubkey(pubkey string) (*BlockBuilderEntry, err
 	return nil, nil
 }
 
-func (db MockDB) SetBlockBuilderStatus(pubkey string, isHighPrio, isBlacklisted bool) error {
+func (db MockDB) SetBlockBuilderStatus(pubkey string, builderStatus common.BlockBuilderStatusCode) error {
 	return nil
 }
 
@@ -100,3 +100,7 @@ func (db MockDB) IncBlockBuilderStatsAfterGetHeader(slot uint64, blockhash strin
 func (db MockDB) IncBlockBuilderStatsAfterGetPayload(builderPubkey string) error {
 	return nil
 }
+
+func (db MockDB) SaveValidatorRefund(bidTrace *common.BidTraceV2, signedBlindedBeaconBlock *types.SignedBlindedBeaconBlock) error {
+	return nil
+}

database/types.go

@@ -188,8 +188,7 @@ type BlockBuilderEntry struct {
 	BuilderPubkey string `db:"builder_pubkey" json:"builder_pubkey"`
 	Description   string `db:"description"    json:"description"`
 
-	IsHighPrio    bool `db:"is_high_prio"   json:"is_high_prio"`
-	IsBlacklisted bool `db:"is_blacklisted" json:"is_blacklisted"`
+	BuilderStatus uint8 `db:"builder_status"   json:"builder_status"`
 
 	LastSubmissionID   sql.NullInt64 `db:"last_submission_id"   json:"last_submission_id"`
 	LastSubmissionSlot uint64        `db:"last_submission_slot" json:"last_submission_slot"`
@@ -199,3 +198,18 @@ type BlockBuilderEntry struct {
 
 	NumSentGetPayload uint64 `db:"num_sent_getpayload" json:"num_sent_getpayload"`
 }
+
+type ValidatorRefundEntry struct {
+	ID         int64     `db:"id"`
+	InsertedAt time.Time `db:"inserted_at"`
+
+	SignedBlindedBeaconBlock sql.NullString `db:"signed_blinded_beacon_block"`
+
+	Slot  uint64 `db:"slot"`
+	Epoch uint64 `db:"epoch"`
+
+	BuilderPubkey  string `db:"builder_pubkey"`
+	ProposerPubkey string `db:"proposer_pubkey"`
+
+	Value string `db:"value"`
+}

database/vars/tables.go

@@ -12,4 +12,5 @@ var (
 	TableBuilderBlockSubmission = tableBase + "_builder_block_submission"
 	TableDeliveredPayload       = tableBase + "_payload_delivered"
 	TableBlockBuilder           = tableBase + "_blockbuilder"
+	TableValidatorRefunds       = tableBase + "_validator_refunds"
 )

datastore/redis.go

@@ -37,9 +37,23 @@ type BlockBuilderStatus string
 var (
 	RedisBlockBuilderStatusLowPrio     BlockBuilderStatus = ""
 	RedisBlockBuilderStatusHighPrio    BlockBuilderStatus = "high-prio"
+	RedisBlockBuilderStatusOptimistic  BlockBuilderStatus = "optimistic"
 	RedisBlockBuilderStatusBlacklisted BlockBuilderStatus = "blacklisted"
 )
 
+func StatusStringFromCode(b common.BlockBuilderStatusCode) string {
+	switch b {
+	case common.Optimistic:
+		return string(RedisBlockBuilderStatusOptimistic)
+	case common.HighPrio:
+		return string(RedisBlockBuilderStatusHighPrio)
+	case common.Blacklisted:
+		return string(RedisBlockBuilderStatusBlacklisted)
+	default:
+		return string(RedisBlockBuilderStatusLowPrio)
+	}
+}
+
 func PubkeyHexToLowerStr(pk types.PubkeyHex) string {
 	return strings.ToLower(string(pk))
 }
@@ -327,14 +341,21 @@ func (r *RedisCache) SetBlockBuilderStatus(builderPubkey string, status BlockBui
 	return r.client.HSet(context.Background(), r.keyBlockBuilderStatus, builderPubkey, string(status)).Err()
 }
 
-func (r *RedisCache) GetBlockBuilderStatus(builderPubkey string) (isHighPrio, isBlacklisted bool, err error) {
+func (r *RedisCache) GetBlockBuilderStatus(builderPubkey string) (code common.BlockBuilderStatusCode, err error) {
 	res, err := r.client.HGet(context.Background(), r.keyBlockBuilderStatus, builderPubkey).Result()
 	if errors.Is(err, redis.Nil) {
-		return false, false, nil
+		return code, nil
+	}
+	switch status := BlockBuilderStatus(res); status {
+	case RedisBlockBuilderStatusHighPrio:
+		return common.HighPrio, nil
+	case RedisBlockBuilderStatusOptimistic:
+		return common.Optimistic, nil
+	case RedisBlockBuilderStatusBlacklisted:
+		return common.Blacklisted, nil
+	default:
+		return common.LowPrio, nil
 	}
-	isHighPrio = BlockBuilderStatus(res) == RedisBlockBuilderStatusHighPrio
-	isBlacklisted = BlockBuilderStatus(res) == RedisBlockBuilderStatusBlacklisted
-	return isHighPrio, isBlacklisted, err
 }
 
 func (r *RedisCache) GetBuilderLatestPayloadReceivedAt(slot uint64, builderPubkey, parentHash, proposerPubkey string) (int64, error) {

datastore/utils.go

@@ -1,11 +1,16 @@
 package datastore
 
-func MakeBlockBuilderStatus(isHighPrio, isBlacklisted bool) BlockBuilderStatus {
-	if isBlacklisted {
-		return RedisBlockBuilderStatusBlacklisted
-	} else if isHighPrio {
+import "github.com/flashbots/mev-boost-relay/common"
+
+func MakeBlockBuilderStatus(c common.BlockBuilderStatusCode) BlockBuilderStatus {
+	switch c {
+	case common.HighPrio:
 		return RedisBlockBuilderStatusHighPrio
-	} else {
+	case common.Optimistic:
+		return RedisBlockBuilderStatusOptimistic
+	case common.Blacklisted:
+		return RedisBlockBuilderStatusBlacklisted
+	default:
 		return RedisBlockBuilderStatusLowPrio
 	}
 }