feat(genesis,protocol): add IIP-59 era params + IsEraBoundary helper

Additive scaffolding for the era-based voter reward distribution
described in the design doc (IIP-59 §8):

- blockchain/genesis: three new Rewarding fields
  - EpochsPerRewardEra (default 24): epochs per voter-reward era
  - VoterBudgetPerBlock (default 2000): max voters credited per block
    during the era-boundary chunked credit path
  - CompoundBatchSize (default 500): max voters swept per block by the
    background compound sweep
  Not part of the genesis Hash proto — no consensus impact until a
  subsequent PR wires them into a fork-gated code path.

- action/protocol: IsEraBoundary(epochNum, epochsPerEra) helper.
  Epoch 0 is never a boundary; epochsPerEra=0 disables the cadence
  entirely so existing tests are undisturbed.

Follow-up PRs (B/C/D) consume these; no behavioral change here.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: envestcc

action/protocol/context.go

@@ -442,3 +442,14 @@ func GetVMConfigCtx(ctx context.Context) (vm.Config, bool) {
 	cfg, ok := ctx.Value(vmConfigContextKey{}).(vm.Config)
 	return cfg, ok
 }
+
+// IsEraBoundary reports whether the given epoch number falls on an IIP-59 voter reward era boundary.
+// An era boundary is any epoch where epochNum%epochsPerEra == 0. Epoch 0 is never a boundary because
+// the genesis pre-epoch has no rewards to distribute; the first live boundary is at epoch epochsPerEra.
+// epochsPerEra == 0 disables era boundaries entirely (used by tests that opt out of the era cadence).
+func IsEraBoundary(epochNum, epochsPerEra uint64) bool {
+	if epochsPerEra == 0 || epochNum == 0 {
+		return false
+	}
+	return epochNum%epochsPerEra == 0
+}

action/protocol/context_test.go

@@ -183,3 +183,30 @@ func TestGetVMConfigCtx(t *testing.T) {
 	require.True(ok)
 	require.True(ret.NoBaseFee)
 }
+
+func TestIsEraBoundary(t *testing.T) {
+	require := require.New(t)
+
+	for _, c := range []struct {
+		name         string
+		epochNum     uint64
+		epochsPerEra uint64
+		want         bool
+	}{
+		{"epoch zero never boundary", 0, 24, false},
+		{"epoch zero with disabled cadence", 0, 0, false},
+		{"epochsPerEra zero disables boundaries", 100, 0, false},
+		{"first live boundary at epoch = epochsPerEra", 24, 24, true},
+		{"exact multiple", 48, 24, true},
+		{"one before boundary", 23, 24, false},
+		{"one after boundary", 25, 24, false},
+		{"epochsPerEra of 1 makes every non-zero epoch a boundary", 1, 1, true},
+		{"epochsPerEra of 1 also holds for arbitrary epochs", 12345, 1, true},
+		{"large multiple", 24 * 30, 24, true},
+		{"large non-multiple", 24*30 + 1, 24, false},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			require.Equal(c.want, IsEraBoundary(c.epochNum, c.epochsPerEra))
+		})
+	}
+}

blockchain/genesis/genesis.go

@@ -163,6 +163,9 @@ func defaultConfig() Genesis {
 			FoundationBonusP2EndEpoch:      18458,
 			ProductivityThreshold:          85,
 			WakeBlockRewardStr:             "4000000000000000000",
+			EpochsPerRewardEra:             24,
+			VoterBudgetPerBlock:            2000,
+			CompoundBatchSize:              500,
 		},
 		Staking: Staking{
 			VoteWeightCalConsts: VoteWeightCalConsts{
@@ -493,6 +496,16 @@ type (
 		ProductivityThreshold uint64 `yaml:"productivityThreshold"`
 		// WakeBlockRewardStr is the block reward amount, in decimal string format, effective from the Wake height
 		WakeBlockRewardStr string `yaml:"wakeBlockRewardStr"`
+		// EpochsPerRewardEra is the number of epochs per IIP-59 voter reward era. Era boundaries are epochs where
+		// epochNum%EpochsPerRewardEra==0. Only consulted when the IIP-59 voter reward distribution feature is active.
+		EpochsPerRewardEra uint64 `yaml:"epochsPerRewardEra"`
+		// VoterBudgetPerBlock is the maximum number of voters credited per block during the era-boundary chunked
+		// credit path (IIP-59 Phase 2). 0 falls back to a single-block drain, preserving pre-IIP-59 behavior for
+		// tests that never touch the field.
+		VoterBudgetPerBlock uint64 `yaml:"voterBudgetPerBlock"`
+		// CompoundBatchSize is the maximum number of voters processed per block by the Phase 3 background compound
+		// sweep. 0 disables the sweep (voters compound lazily at Claim time only).
+		CompoundBatchSize uint64 `yaml:"compoundBatchSize"`
 	}
 	// Staking contains the configs for staking protocol
 	Staking struct {

blockchain/genesis/genesis_test.go

@@ -130,3 +130,12 @@ func TestGenesisMapEmpty(t *testing.T) {
 	// Therefore, the default map must be empty.
 	r.Empty(g.Account.InitBalanceMap, "InitBalanceMap should be empty")
 }
+
+func TestIIP59EraDefaults(t *testing.T) {
+	r := require.New(t)
+	cfg, err := New("")
+	r.NoError(err)
+	r.Equal(uint64(24), cfg.Rewarding.EpochsPerRewardEra)
+	r.Equal(uint64(2000), cfg.Rewarding.VoterBudgetPerBlock)
+	r.Equal(uint64(500), cfg.Rewarding.CompoundBatchSize)
+}