fix(fip-0118): correct reward bootstrap and genesis state

Author: rvagg

builtin/methods.go

@@ -38,15 +38,31 @@ var MethodsCron = struct {
 }
 
 var MethodsReward = struct {
-	Constructor      abi.MethodNum
-	AwardBlockReward abi.MethodNum
-	ThisEpochReward  abi.MethodNum
-	UpdateNetworkKPI abi.MethodNum
+	Constructor               abi.MethodNum
+	AwardBlockReward          abi.MethodNum
+	ThisEpochReward           abi.MethodNum
+	UpdateNetworkKPI          abi.MethodNum
+	SetWeightRecordsExported  abi.MethodNum
+	StepWeightRecordsExported abi.MethodNum
+	RegisterStreamExported    abi.MethodNum
+	RemoveStreamExported      abi.MethodNum
+	SetDistributionExported   abi.MethodNum
+	SetSharesExported         abi.MethodNum
+	CancelPendingExported     abi.MethodNum
+	ClaimExported             abi.MethodNum
 }{
 	MethodConstructor,
 	2,
 	3,
 	4,
+	MustGenerateFRCMethodNum("SetWeightRecords"),
+	MustGenerateFRCMethodNum("StepWeightRecords"),
+	MustGenerateFRCMethodNum("RegisterStream"),
+	MustGenerateFRCMethodNum("RemoveStream"),
+	MustGenerateFRCMethodNum("SetDistribution"),
+	MustGenerateFRCMethodNum("SetShares"),
+	MustGenerateFRCMethodNum("CancelPending"),
+	MustGenerateFRCMethodNum("Claim"),
 }
 
 var MethodsMultisig = struct {

builtin/v19/migration/reward.go

@@ -23,8 +23,8 @@ type rewardMigrator struct {
 	swaActor          address.Address
 }
 
-func newRewardMigrator(config RewardMigrationConfig, activationEpoch abi.ChainEpoch, outCodeCID cid.Cid) (*rewardMigrator, error) {
-	streams, accruals, err := reward19.ValidateMigrationStreams(config.Streams, activationEpoch)
+func newRewardMigrator(config RewardMigrationConfig, outCodeCID cid.Cid) (*rewardMigrator, error) {
+	streams, accruals, err := reward19.ValidateMigrationStreams(config.Streams, config.ActivationEpoch)
 	if err != nil {
 		return nil, xerrors.Errorf("invalid reward migration streams: %w", err)
 	}

builtin/v19/migration/reward_test.go

@@ -11,6 +11,7 @@ import (
 	reward18 "github.com/filecoin-project/go-state-types/builtin/v18/reward"
 	smoothing18 "github.com/filecoin-project/go-state-types/builtin/v18/util/smoothing"
 	reward19 "github.com/filecoin-project/go-state-types/builtin/v19/reward"
+	adt19 "github.com/filecoin-project/go-state-types/builtin/v19/util/adt"
 	"github.com/filecoin-project/go-state-types/migration"
 	"github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
@@ -28,6 +29,7 @@ func validRewardMigrationConfig(t *testing.T, activationEpoch abi.ChainEpoch) Re
 	t.Helper()
 	pct := reward19.Denom / 100
 	return RewardMigrationConfig{
+		ActivationEpoch:   activationEpoch,
 		SWATimelockEpochs: 20_160,
 		SWAActor:          migrationIDAddress(t, 100),
 		Streams: []reward19.RegisterStreamParams{
@@ -74,7 +76,7 @@ func TestRewardMigration(t *testing.T) {
 	activationEpoch := abi.ChainEpoch(100)
 	config := validRewardMigrationConfig(t, activationEpoch)
 	outCodeCID := cid.MustParse("bafy2bzaca4aaaaaaaaaqk")
-	migrator, err := newRewardMigrator(config, activationEpoch, outCodeCID)
+	migrator, err := newRewardMigrator(config, outCodeCID)
 	req.NoError(err)
 	result, err := migrator.MigrateState(ctx, store, migration.ActorMigrationInput{Address: address.TestAddress, Head: inHead})
 	req.NoError(err)
@@ -98,18 +100,90 @@ func TestRewardMigration(t *testing.T) {
 	req.Equal(config.SWATimelockEpochs, outState.SWATimelockEpochs)
 	req.Equal(config.SWAActor, outState.SWAActor)
 
-	var streams reward19.StreamsState
-	req.NoError(store.Get(ctx, outState.StreamsRoot, &streams))
+	streams, err := outState.LoadStreams(adt19.WrapStore(ctx, store))
+	req.NoError(err)
 	req.Len(streams.Streams, 2)
 	req.Equal(reward19.StreamID(1), streams.Streams[0].ID)
+	req.Equal(config.Streams[0].Weight, streams.Streams[0].Weight)
 	req.Nil(streams.Streams[0].Distribution)
 	req.Equal(reward19.StreamID(2), streams.Streams[1].ID)
+	req.Equal(config.Streams[1].Weight, streams.Streams[1].Weight)
 	req.Equal(config.Streams[1].Distribution.Writer, streams.Streams[1].Distribution.Writer)
 	req.Equal(config.Streams[1].Distribution.Shares, streams.Streams[1].Distribution.Shares)
 	req.Empty(streams.Tombstones)
 	req.Empty(streams.PendingWrites)
 }
 
+func TestRewardMigrationDropsStoredRewardTotals(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	req := require.New(t)
+	store := cbor.NewMemCborStore()
+	activationEpoch := abi.ChainEpoch(100)
+	migrator, err := newRewardMigrator(
+		validRewardMigrationConfig(t, activationEpoch),
+		cid.MustParse("bafy2bzaca4aaaaaaaaaqk"),
+	)
+	req.NoError(err)
+
+	base := reward18.State{
+		CumsumBaseline:          big.NewInt(1),
+		CumsumRealized:          big.NewInt(2),
+		EffectiveNetworkTime:    3,
+		EffectiveBaselinePower:  big.NewInt(4),
+		ThisEpochReward:         abi.NewTokenAmount(5),
+		ThisEpochRewardSmoothed: smoothing18.NewEstimate(big.NewInt(6), big.NewInt(7)),
+		ThisEpochBaselinePower:  big.NewInt(8),
+		Epoch:                   9,
+		TotalStoragePowerReward: abi.NewTokenAmount(10),
+		SimpleTotal:             abi.NewTokenAmount(11),
+		BaselineTotal:           abi.NewTokenAmount(12),
+	}
+	alternate := base
+	alternate.SimpleTotal = abi.NewTokenAmount(13)
+	alternate.BaselineTotal = abi.NewTokenAmount(14)
+	req.NotEqual(base.SimpleTotal, alternate.SimpleTotal)
+	req.NotEqual(base.BaselineTotal, alternate.BaselineTotal)
+
+	migrate := func(input reward18.State) reward19.State {
+		head, err := store.Put(ctx, &input)
+		req.NoError(err)
+		result, err := migrator.MigrateState(ctx, store, migration.ActorMigrationInput{
+			Address: address.TestAddress,
+			Head:    head,
+		})
+		req.NoError(err)
+		var output reward19.State
+		req.NoError(store.Get(ctx, result.NewHead, &output))
+		return output
+	}
+
+	req.Equal(migrate(base), migrate(alternate))
+}
+
+func TestNewRewardMigratorAcceptsAlternativeBootstrapWeights(t *testing.T) {
+	activationEpoch := abi.ChainEpoch(100)
+	pct := reward19.Denom / 100
+	config := validRewardMigrationConfig(t, activationEpoch)
+	config.Streams[0].Weight = reward19.WeightRecord{
+		VStart: 80 * pct,
+		Slope:  -1,
+		TStart: activationEpoch,
+		Floor:  60 * pct,
+		Cap:    80 * pct,
+	}
+	config.Streams[1].Weight = reward19.WeightRecord{
+		VStart: 20 * pct,
+		Slope:  1,
+		TStart: activationEpoch,
+		Floor:  10 * pct,
+		Cap:    20 * pct,
+	}
+
+	_, err := newRewardMigrator(config, cid.MustParse("bafy2bzaca4aaaaaaaaaqk"))
+	require.NoError(t, err)
+}
+
 func TestNewRewardMigratorRejectsInvalidConfig(t *testing.T) {
 	activationEpoch := abi.ChainEpoch(100)
 	outCodeCID := cid.MustParse("bafy2bzaca4aaaaaaaaaqk")
@@ -140,11 +214,11 @@ func TestNewRewardMigratorRejectsInvalidConfig(t *testing.T) {
 			expected: "requires exactly two streams",
 		},
 		{
-			name: "wrong bootstrap weight",
+			name: "starting weights under-sum",
 			mutate: func(config *RewardMigrationConfig) {
-				config.Streams[0].Weight.VStart--
+				config.Streams[1].Weight.VStart--
 			},
-			expected: "consensus bootstrap weight is invalid",
+			expected: "bootstrap starting weights must sum to denominator",
 		},
 		{
 			name: "unequal slopes",
@@ -176,13 +250,31 @@ func TestNewRewardMigratorRejectsInvalidConfig(t *testing.T) {
 			},
 			expected: "SWA actor is not an ID address",
 		},
+		{
+			name: "non-ID SRA actor",
+			mutate: func(config *RewardMigrationConfig) {
+				addr, err := address.NewDelegatedAddress(10, []byte{1})
+				require.NoError(t, err)
+				config.Streams[1].Distribution.Writer = addr
+			},
+			expected: "distribution writer",
+		},
+		{
+			name: "non-ID initial orchestrator",
+			mutate: func(config *RewardMigrationConfig) {
+				addr, err := address.NewDelegatedAddress(10, []byte{1})
+				require.NoError(t, err)
+				config.Streams[1].Distribution.Shares[0].Recipient = addr
+			},
+			expected: "share recipient",
+		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			config := validRewardMigrationConfig(t, activationEpoch)
 			tc.mutate(&config)
-			_, err := newRewardMigrator(config, activationEpoch, outCodeCID)
+			_, err := newRewardMigrator(config, outCodeCID)
 			require.ErrorContains(t, err, tc.expected)
 		})
 	}

builtin/v19/migration/top.go

@@ -21,6 +21,7 @@ import (
 )
 
 type RewardMigrationConfig struct {
+	ActivationEpoch   abi.ChainEpoch
 	SWATimelockEpochs abi.ChainEpoch
 	SWAActor          address.Address
 	Streams           []reward19.RegisterStreamParams
@@ -108,7 +109,7 @@ func MigrateStateTree(ctx context.Context, store cbor.IpldStore, newManifestCID
 	if !ok {
 		return cid.Undef, xerrors.Errorf("code cid for reward actor not found in new manifest")
 	}
-	rewardMigrator, err := newRewardMigrator(rewardConfig, priorEpoch+1, reward19CID)
+	rewardMigrator, err := newRewardMigrator(rewardConfig, reward19CID)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("failed to create reward migrator: %w", err)
 	}

builtin/v19/reward/invariants.go

@@ -27,7 +27,11 @@ func CheckStateInvariants(st *State, store adt.Store, priorEpoch abi.ChainEpoch,
 	acc.Require(st.EffectiveNetworkTime <= st.Epoch, "effective network time %d greater than state epoch %d", st.EffectiveNetworkTime, st.Epoch)
 	acc.Require(st.CumsumRealized.LessThanEqual(st.CumsumBaseline), "cumsum realized %v > cumsum baseline %v", st.CumsumRealized, st.CumsumBaseline)
 	acc.Require(st.CumsumRealized.GreaterThanEqual(big.Zero()), "cumsum realized negative (%v)", st.CumsumRealized)
-	acc.Require(st.EffectiveBaselinePower.LessThanEqual(st.ThisEpochBaselinePower), "effective baseline power > baseline power")
+	// Before the first state transition, the effective baseline is anchored at
+	// epoch 0 while ThisEpochBaselinePower is anchored at epoch -1.
+	baselineOrdered := st.Epoch == 0 && st.EffectiveNetworkTime == 0 ||
+		st.EffectiveBaselinePower.LessThanEqual(st.ThisEpochBaselinePower)
+	acc.Require(baselineOrdered, "effective baseline power > baseline power")
 
 	for _, total := range []struct {
 		name   string
@@ -55,8 +59,8 @@ func CheckStateInvariants(st *State, store adt.Store, priorEpoch abi.ChainEpoch,
 		acc.Require(row.Amount.GreaterThanEqual(big.Zero()), "explicit-stream accrual for stream %d is negative (%v)", row.ID, row.Amount)
 	}
 
-	var streams StreamsState
-	if err := store.Get(store.Context(), st.StreamsRoot, &streams); err != nil {
+	streams, err := st.LoadStreams(store)
+	if err != nil {
 		acc.Addf("error loading streams state: %v", err)
 		return &StateSummary{}, acc
 	}
@@ -67,7 +71,7 @@ func CheckStateInvariants(st *State, store adt.Store, priorEpoch abi.ChainEpoch,
 		PendingWriteCount: len(streams.PendingWrites),
 	}
 	// Mirrors actors/reward/src/streams.rs::validate_streams_state.
-	if err := validateStreamsState(&streams, st.Accrued, priorEpoch+1); err != nil {
+	if err := validateStreamsState(streams, st.Accrued, priorEpoch+1); err != nil {
 		acc.Addf("invalid streams state: %v", err)
 	}
 
@@ -122,7 +126,7 @@ func CheckStateInvariants(st *State, store adt.Store, priorEpoch abi.ChainEpoch,
 	}
 
 	// Mirrors actors/reward/src/streams.rs::compute_service_liability.
-	liabilities, err := computeExplicitLiability(&streams, st.Accrued)
+	liabilities, err := computeExplicitLiability(streams, st.Accrued)
 	if err != nil {
 		acc.Addf("error computing explicit-stream liabilities: %v", err)
 	} else {

builtin/v19/reward/invariants_test.go

@@ -21,9 +21,18 @@ import (
 func validInvariantState(t *testing.T) (*State, *StreamsState, adt.Store) {
 	t.Helper()
 	store := adt.WrapStore(context.Background(), cbor.NewCborStore(test_util.NewBlockStoreInMemory()))
-	st, err := ConstructState(store, big.Zero())
-	require.NoError(t, err)
-	st.EffectiveBaselinePower = big.Zero()
+	st := &State{
+		CumsumBaseline:         big.Zero(),
+		CumsumRealized:         big.Zero(),
+		EffectiveBaselinePower: big.Zero(),
+		ThisEpochReward:        big.Zero(),
+		ThisEpochBaselinePower: big.Zero(),
+		Epoch:                  0,
+		TotalMintedReward:      big.Zero(),
+		TotalBurnMinted:        big.Zero(),
+		TotalExplicitMinted:    big.Zero(),
+		SWAActor:               idAddress(t, 99),
+	}
 
 	pct := Denom / 100
 	streams := &StreamsState{
@@ -79,6 +88,32 @@ func amountRows(t *testing.T, first, count uint64) []RecipientAmount {
 	return rows
 }
 
+func TestConstructState(t *testing.T) {
+	store := adt.WrapStore(context.Background(), cbor.NewCborStore(test_util.NewBlockStoreInMemory()))
+	st, err := ConstructState(store, big.Zero())
+	require.NoError(t, err)
+
+	streams, err := st.LoadStreams(store)
+	require.NoError(t, err)
+	require.Equal(t, []Stream{{
+		ID: 1,
+		Weight: WeightRecord{
+			VStart: Denom,
+			TStart: -1,
+			Floor:  Denom,
+			Cap:    Denom,
+		},
+	}}, streams.Streams)
+	require.Empty(t, st.Accrued)
+	require.Empty(t, streams.Tombstones)
+	require.Empty(t, streams.PendingWrites)
+	require.Equal(t, builtin.SystemActorAddr, st.SWAActor)
+
+	summary, acc := CheckStateInvariants(st, store, st.Epoch-1, StorageMiningAllocationCheck)
+	require.Empty(t, acc.Messages())
+	require.Equal(t, &StateSummary{StreamCount: 1}, summary)
+}
+
 func TestCheckStateInvariants(t *testing.T) {
 	st, _, store := validInvariantState(t)
 	summary, acc := CheckStateInvariants(st, store, st.Epoch-1, StorageMiningAllocationCheck)