state-diff configs

Author: Inspector-Butters

beacon-chain/db/kv/BUILD.bazel

@@ -27,6 +27,7 @@ go_library(
         "p2p.go",
         "schema.go",
         "state.go",
+        "state_diff_cache.go",
         "state_summary.go",
         "state_summary_cache.go",
         "utils.go",
@@ -41,6 +42,7 @@ go_library(
         "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
+        "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

beacon-chain/db/kv/kv.go

@@ -91,6 +91,7 @@ type Store struct {
 	blockCache          *ristretto.Cache[string, interfaces.ReadOnlySignedBeaconBlock]
 	validatorEntryCache *ristretto.Cache[[]byte, *ethpb.Validator]
 	stateSummaryCache   *stateSummaryCache
+	stateDiffCache      *stateDiffCache
 	ctx                 context.Context
 }
 
@@ -112,6 +113,7 @@ var Buckets = [][]byte{
 	lightClientUpdatesBucket,
 	lightClientBootstrapBucket,
 	lightClientSyncCommitteeBucket,
+	stateDiffBucket,
 	// Indices buckets.
 	blockSlotIndicesBucket,
 	stateSlotIndicesBucket,
@@ -201,6 +203,14 @@ func NewKVStore(ctx context.Context, dirPath string, opts ...KVStoreOption) (*St
 		return nil, err
 	}
 
+	if features.Get().EnableStateDiff {
+		sdCache, err := newStateDiffCache(kv)
+		if err != nil {
+			return nil, err
+		}
+		kv.stateDiffCache = sdCache
+	}
+
 	return kv, nil
 }
 

beacon-chain/db/kv/schema.go

@@ -16,6 +16,7 @@ var (
 	stateValidatorsBucket = []byte("state-validators")
 	feeRecipientBucket    = []byte("fee-recipient")
 	registrationBucket    = []byte("registration")
+	stateDiffBucket       = []byte("state-diff")
 
 	// Light Client Updates Bucket
 	lightClientUpdatesBucket       = []byte("light-client-updates")

beacon-chain/db/kv/state_diff_cache.go

@@ -0,0 +1,77 @@
+package kv
+
+import (
+	"encoding/binary"
+	"errors"
+	"sync"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
+	"go.etcd.io/bbolt"
+)
+
+type stateDiffCache struct {
+	sync.RWMutex
+	anchors []state.ReadOnlyBeaconState
+	offset  uint64
+}
+
+func newStateDiffCache(s *Store) (*stateDiffCache, error) {
+	var offset uint64
+
+	err := s.db.View(func(tx *bbolt.Tx) error {
+		bucket := tx.Bucket(stateDiffBucket)
+		if bucket == nil {
+			return bbolt.ErrBucketNotFound
+		}
+
+		offsetBytes := bucket.Get([]byte("offset"))
+		if offsetBytes == nil {
+			return errors.New("state diff cache: offset not found")
+		}
+		offset = binary.LittleEndian.Uint64(offsetBytes)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &stateDiffCache{
+		anchors: make([]state.ReadOnlyBeaconState, len(flags.Get().StateDiffExponents)),
+		offset:  offset,
+	}, nil
+}
+
+func (c *stateDiffCache) getAnchor(level int) state.ReadOnlyBeaconState {
+	c.RLock()
+	defer c.RUnlock()
+	return c.anchors[level]
+}
+
+func (c *stateDiffCache) setAnchor(level int, anchor state.ReadOnlyBeaconState) error {
+	c.Lock()
+	defer c.Unlock()
+	if level >= len(c.anchors) || level < 0 {
+		return errors.New("state diff cache: anchor level out of range")
+	}
+	c.anchors[level] = anchor
+	return nil
+}
+
+func (c *stateDiffCache) getOffset() uint64 {
+	c.RLock()
+	defer c.RUnlock()
+	return c.offset
+}
+
+func (c *stateDiffCache) setOffset(offset uint64) {
+	c.Lock()
+	defer c.Unlock()
+	c.offset = offset
+}
+
+func (c *stateDiffCache) clearAnchors() {
+	c.Lock()
+	defer c.Unlock()
+	c.anchors = make([]state.ReadOnlyBeaconState, len(flags.Get().StateDiffExponents))
+}

beacon-chain/node/node.go

@@ -277,7 +277,10 @@ func configureBeacon(cliCtx *cli.Context) error {
 		return errors.Wrap(err, "could not configure beacon chain")
 	}
 
-	flags.ConfigureGlobalFlags(cliCtx)
+	err := flags.ConfigureGlobalFlags(cliCtx)
+	if err != nil {
+		return errors.Wrap(err, "could not configure global flags")
+	}
 
 	if err := configureChainConfig(cliCtx); err != nil {
 		return errors.Wrap(err, "could not configure chain config")

changelog/bastin_state-diff-configs.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add initial configs for the state-diff feature.

cmd/beacon-chain/flags/BUILD.bazel

@@ -18,15 +18,23 @@ go_library(
     ],
     deps = [
         "//cmd:go_default_library",
+        "//config/features:go_default_library",
         "//config/params:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
     ],
 )
 
 go_test(
     name = "go_default_test",
-    srcs = ["api_module_test.go"],
+    srcs = [
+        "api_module_test.go",
+        "config_test.go",
+    ],
     embed = [":go_default_library"],
-    deps = ["//testing/assert:go_default_library"],
+    deps = [
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+    ],
 )

cmd/beacon-chain/flags/base.go

@@ -344,4 +344,10 @@ var (
 		Usage: "Maximum number of signatures to batch verify at once for beacon attestation p2p gossip.",
 		Value: 1000,
 	}
+	// StateDiffExponents defines the state diff tree hierarchy levels.
+	StateDiffExponents = &cli.IntSliceFlag{
+		Name:  "state-diff-exponents",
+		Usage: "A comma-separated list of exponents (of 2) in decreasing order, defining the state diff hierarchy levels. The last exponent must be greater than or equal to 5.",
+		Value: cli.NewIntSlice(21, 18, 16, 13, 11, 9, 5),
+	}
 )

cmd/beacon-chain/flags/config.go

@@ -1,7 +1,11 @@
 package flags
 
 import (
+	"math"
+
 	"github.com/OffchainLabs/prysm/v6/cmd"
+	"github.com/OffchainLabs/prysm/v6/config/features"
+	"github.com/pkg/errors"
 	"github.com/urfave/cli/v2"
 )
 
@@ -19,6 +23,7 @@ type GlobalFlags struct {
 	BlobBatchLimitBurstFactor       int
 	DataColumnBatchLimit            int
 	DataColumnBatchLimitBurstFactor int
+	StateDiffExponents              []int
 }
 
 var globalConfig *GlobalFlags
@@ -38,7 +43,7 @@ func Init(c *GlobalFlags) {
 
 // ConfigureGlobalFlags initializes the global config.
 // based on the provided cli context.
-func ConfigureGlobalFlags(ctx *cli.Context) {
+func ConfigureGlobalFlags(ctx *cli.Context) error {
 	cfg := &GlobalFlags{}
 
 	if ctx.Bool(SubscribeToAllSubnets.Name) {
@@ -51,6 +56,18 @@ func ConfigureGlobalFlags(ctx *cli.Context) {
 		cfg.SubscribeAllDataSubnets = true
 	}
 
+	// State-diff-exponents
+	cfg.StateDiffExponents = ctx.IntSlice(StateDiffExponents.Name)
+	if features.Get().EnableStateDiff {
+		if err := validateStateDiffExponents(cfg.StateDiffExponents); err != nil {
+			return err
+		}
+	} else {
+		if ctx.IsSet(StateDiffExponents.Name) {
+			log.Warn("--state-diff-exponents is set but --enable-state-diff is not; the value will be ignored.")
+		}
+	}
+
 	cfg.BlockBatchLimit = ctx.Int(BlockBatchLimit.Name)
 	cfg.BlockBatchLimitBurstFactor = ctx.Int(BlockBatchLimitBurstFactor.Name)
 	cfg.BlobBatchLimit = ctx.Int(BlobBatchLimit.Name)
@@ -63,6 +80,7 @@ func ConfigureGlobalFlags(ctx *cli.Context) {
 	configureMinimumPeers(ctx, cfg)
 
 	Init(cfg)
+	return nil
 }
 
 // MaxDialIsActive checks if the user has enabled the max dial flag.
@@ -78,3 +96,21 @@ func configureMinimumPeers(ctx *cli.Context, cfg *GlobalFlags) {
 		cfg.MinimumSyncPeers = maxPeers
 	}
 }
+
+func validateStateDiffExponents(exponents []int) error {
+	length := len(exponents)
+	if length == 0 || length > 15 {
+		return errors.New("state diff exponents must contain between 1 and 15 values")
+	}
+	if exponents[length-1] < 5 {
+		return errors.New("the last state diff exponent must be at least 5")
+	}
+	prev := math.MaxInt
+	for _, exp := range exponents {
+		if exp >= prev {
+			return errors.New("state diff exponents must be in strictly decreasing order")
+		}
+		prev = exp
+	}
+	return nil
+}

cmd/beacon-chain/flags/config_test.go

@@ -0,0 +1,38 @@
+package flags
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+)
+
+func TestValidateStateDiffExponents(t *testing.T) {
+	tests := []struct {
+		idx       int
+		exponents []int
+		wantErr   bool
+		errMsg    string
+	}{
+		{idx: 1, exponents: []int{0, 1, 2}, wantErr: true, errMsg: "at least 5"},
+		{idx: 2, exponents: []int{1, 2, 3}, wantErr: true, errMsg: "at least 5"},
+		{idx: 3, exponents: []int{9, 8, 4}, wantErr: true, errMsg: "at least 5"},
+		{idx: 4, exponents: []int{3, 4, 5}, wantErr: true, errMsg: "decreasing"},
+		{idx: 5, exponents: []int{15, 14, 14, 12, 11}, wantErr: true, errMsg: "decreasing"},
+		{idx: 6, exponents: []int{15, 14, 13, 12, 11}, wantErr: false},
+		{idx: 7, exponents: []int{21, 18, 16, 13, 11, 9, 5}, wantErr: false},
+		{idx: 8, exponents: []int{30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 18, 16, 13, 11, 9, 5}, wantErr: true, errMsg: "between 1 and 15 values"},
+		{idx: 9, exponents: []int{}, wantErr: true, errMsg: "between 1 and 15 values"},
+	}
+
+	for _, tt := range tests {
+		t.Run(strconv.Itoa(tt.idx), func(t *testing.T) {
+			err := validateStateDiffExponents(tt.exponents)
+			if tt.wantErr {
+				require.ErrorContains(t, tt.errMsg, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}