ACP-77: Implement validator state

database/helpers.go

@@ -54,6 +54,14 @@ func GetUInt64(db KeyValueReader, key []byte) (uint64, error) {
 	return ParseUInt64(b)
 }
 
+func GetOrDefaultUInt64(db KeyValueReader, key []byte, def uint64) (uint64, error) {
+	v, err := GetUInt64(db, key)
+	if err == ErrNotFound {
+		return def, nil
+	}
+	return v, err
+}
+
 func PackUInt64(val uint64) []byte {
 	bytes := make([]byte, Uint64Size)
 	binary.BigEndian.PutUint64(bytes, val)

vms/platformvm/block/executor/proposal_block_test.go

@@ -92,6 +92,8 @@ func TestApricotProposalBlockTimeVerification(t *testing.T) {
 	onParentAccept.EXPECT().GetTimestamp().Return(chainTime).AnyTimes()
 	onParentAccept.EXPECT().GetFeeState().Return(gas.State{}).AnyTimes()
 	onParentAccept.EXPECT().GetAccruedFees().Return(uint64(0)).AnyTimes()
+	onParentAccept.EXPECT().GetSoVExcess().Return(gas.Gas(0)).AnyTimes()
+	onParentAccept.EXPECT().NumActiveSubnetOnlyValidators().Return(0).AnyTimes()
 
 	onParentAccept.EXPECT().GetCurrentStakerIterator().Return(
 		iterator.FromSlice(&state.Staker{
@@ -163,6 +165,8 @@ func TestBanffProposalBlockTimeVerification(t *testing.T) {
 	onParentAccept.EXPECT().GetTimestamp().Return(parentTime).AnyTimes()
 	onParentAccept.EXPECT().GetFeeState().Return(gas.State{}).AnyTimes()
 	onParentAccept.EXPECT().GetAccruedFees().Return(uint64(0)).AnyTimes()
+	onParentAccept.EXPECT().GetSoVExcess().Return(gas.Gas(0)).AnyTimes()
+	onParentAccept.EXPECT().NumActiveSubnetOnlyValidators().Return(0).AnyTimes()
 	onParentAccept.EXPECT().GetCurrentSupply(constants.PrimaryNetworkID).Return(uint64(1000), nil).AnyTimes()
 
 	env.blkManager.(*manager).blkIDToState[parentID] = &blockState{

vms/platformvm/block/executor/standard_block_test.go

@@ -60,6 +60,8 @@ func TestApricotStandardBlockTimeVerification(t *testing.T) {
 	onParentAccept.EXPECT().GetTimestamp().Return(chainTime).AnyTimes()
 	onParentAccept.EXPECT().GetFeeState().Return(gas.State{}).AnyTimes()
 	onParentAccept.EXPECT().GetAccruedFees().Return(uint64(0)).AnyTimes()
+	onParentAccept.EXPECT().GetSoVExcess().Return(gas.Gas(0)).AnyTimes()
+	onParentAccept.EXPECT().NumActiveSubnetOnlyValidators().Return(0).AnyTimes()
 
 	// wrong height
 	apricotChildBlk, err := block.NewApricotStandardBlock(
@@ -135,6 +137,8 @@ func TestBanffStandardBlockTimeVerification(t *testing.T) {
 	onParentAccept.EXPECT().GetTimestamp().Return(chainTime).AnyTimes()
 	onParentAccept.EXPECT().GetFeeState().Return(gas.State{}).AnyTimes()
 	onParentAccept.EXPECT().GetAccruedFees().Return(uint64(0)).AnyTimes()
+	onParentAccept.EXPECT().GetSoVExcess().Return(gas.Gas(0)).AnyTimes()
+	onParentAccept.EXPECT().NumActiveSubnetOnlyValidators().Return(0).AnyTimes()
 
 	txID := ids.GenerateTestID()
 	utxo := &avax.UTXO{

vms/platformvm/block/executor/verifier_test.go

@@ -104,6 +104,8 @@ func TestVerifierVisitProposalBlock(t *testing.T) {
 	parentOnAcceptState.EXPECT().GetTimestamp().Return(timestamp).Times(2)
 	parentOnAcceptState.EXPECT().GetFeeState().Return(gas.State{}).Times(2)
 	parentOnAcceptState.EXPECT().GetAccruedFees().Return(uint64(0)).Times(2)
+	parentOnAcceptState.EXPECT().GetSoVExcess().Return(gas.Gas(0)).Times(2)
+	parentOnAcceptState.EXPECT().NumActiveSubnetOnlyValidators().Return(0).Times(2)
 
 	backend := &backend{
 		lastAccepted: parentID,
@@ -336,6 +338,8 @@ func TestVerifierVisitStandardBlock(t *testing.T) {
 	parentState.EXPECT().GetTimestamp().Return(timestamp).Times(1)
 	parentState.EXPECT().GetFeeState().Return(gas.State{}).Times(1)
 	parentState.EXPECT().GetAccruedFees().Return(uint64(0)).Times(1)
+	parentState.EXPECT().GetSoVExcess().Return(gas.Gas(0)).Times(1)
+	parentState.EXPECT().NumActiveSubnetOnlyValidators().Return(0).Times(1)
 	parentStatelessBlk.EXPECT().Height().Return(uint64(1)).Times(1)
 	mempool.EXPECT().Remove(apricotBlk.Txs()).Times(1)
 
@@ -598,6 +602,8 @@ func TestBanffAbortBlockTimestampChecks(t *testing.T) {
 			s.EXPECT().GetTimestamp().Return(parentTime).Times(3)
 			s.EXPECT().GetFeeState().Return(gas.State{}).Times(3)
 			s.EXPECT().GetAccruedFees().Return(uint64(0)).Times(3)
+			s.EXPECT().GetSoVExcess().Return(gas.Gas(0)).Times(3)
+			s.EXPECT().NumActiveSubnetOnlyValidators().Return(0).Times(3)
 
 			onDecisionState, err := state.NewDiff(parentID, backend)
 			require.NoError(err)
@@ -696,6 +702,8 @@ func TestBanffCommitBlockTimestampChecks(t *testing.T) {
 			s.EXPECT().GetTimestamp().Return(parentTime).Times(3)
 			s.EXPECT().GetFeeState().Return(gas.State{}).Times(3)
 			s.EXPECT().GetAccruedFees().Return(uint64(0)).Times(3)
+			s.EXPECT().GetSoVExcess().Return(gas.Gas(0)).Times(3)
+			s.EXPECT().NumActiveSubnetOnlyValidators().Return(0).Times(3)
 
 			onDecisionState, err := state.NewDiff(parentID, backend)
 			require.NoError(err)
@@ -812,6 +820,8 @@ func TestVerifierVisitStandardBlockWithDuplicateInputs(t *testing.T) {
 	parentState.EXPECT().GetTimestamp().Return(timestamp).Times(1)
 	parentState.EXPECT().GetFeeState().Return(gas.State{}).Times(1)
 	parentState.EXPECT().GetAccruedFees().Return(uint64(0)).Times(1)
+	parentState.EXPECT().GetSoVExcess().Return(gas.Gas(0)).Times(1)
+	parentState.EXPECT().NumActiveSubnetOnlyValidators().Return(0).Times(1)
 	parentStatelessBlk.EXPECT().Parent().Return(grandParentID).Times(1)
 
 	err = verifier.ApricotStandardBlock(blk)

vms/platformvm/service.go

@@ -440,6 +440,7 @@ type GetSubnetResponse struct {
 	// subnet transformation tx ID for an elastic subnet
 	SubnetTransformationTxID ids.ID `json:"subnetTransformationTxID"`
 	// subnet manager information for a permissionless L1
+	ConversionID   ids.ID              `json:"conversionID"`
 	ManagerChainID ids.ID              `json:"managerChainID"`
 	ManagerAddress types.JSONByteSlice `json:"managerAddress"`
 }
@@ -490,12 +491,14 @@ func (s *Service) GetSubnet(_ *http.Request, args *GetSubnetArgs, response *GetS
 		return err
 	}
 
-	switch chainID, addr, err := s.vm.state.GetSubnetManager(args.SubnetID); err {
+	switch conversionID, chainID, addr, err := s.vm.state.GetSubnetConversion(args.SubnetID); err {
 	case nil:
 		response.IsPermissioned = false
+		response.ConversionID = conversionID
 		response.ManagerChainID = chainID
 		response.ManagerAddress = addr
 	case database.ErrNotFound:
+		response.ConversionID = ids.Empty
 		response.ManagerChainID = ids.Empty
 		response.ManagerAddress = []byte(nil)
 	default:

vms/platformvm/state/diff.go

@@ -35,14 +35,17 @@ type diff struct {
 	parentID      ids.ID
 	stateVersions Versions
 
-	timestamp   time.Time
-	feeState    gas.State
-	accruedFees uint64
+	timestamp        time.Time
+	feeState         gas.State
+	sovExcess        gas.Gas
+	accruedFees      uint64
+	parentActiveSOVs int
 
 	// Subnet ID --> supply of native asset of the subnet
 	currentSupply map[ids.ID]uint64
 
 	expiryDiff *expiryDiff
+	sovDiff    *subnetOnlyValidatorsDiff
 
 	currentStakerDiffs diffStakers
 	// map of subnetID -> nodeID -> total accrued delegatee rewards
@@ -52,8 +55,8 @@ type diff struct {
 	addedSubnetIDs []ids.ID
 	// Subnet ID --> Owner of the subnet
 	subnetOwners map[ids.ID]fx.Owner
-	// Subnet ID --> Manager of the subnet
-	subnetManagers map[ids.ID]chainIDAndAddr
+	// Subnet ID --> Conversion of the subnet
+	subnetConversions map[ids.ID]subnetConversion
 	// Subnet ID --> Tx that transforms the subnet
 	transformedSubnets map[ids.ID]*txs.Tx
 
@@ -76,14 +79,17 @@ func NewDiff(
 		return nil, fmt.Errorf("%w: %s", ErrMissingParentState, parentID)
 	}
 	return &diff{
-		parentID:       parentID,
-		stateVersions:  stateVersions,
-		timestamp:      parentState.GetTimestamp(),
-		feeState:       parentState.GetFeeState(),
-		accruedFees:    parentState.GetAccruedFees(),
-		expiryDiff:     newExpiryDiff(),
-		subnetOwners:   make(map[ids.ID]fx.Owner),
-		subnetManagers: make(map[ids.ID]chainIDAndAddr),
+		parentID:          parentID,
+		stateVersions:     stateVersions,
+		timestamp:         parentState.GetTimestamp(),
+		feeState:          parentState.GetFeeState(),
+		sovExcess:         parentState.GetSoVExcess(),
+		accruedFees:       parentState.GetAccruedFees(),
+		parentActiveSOVs:  parentState.NumActiveSubnetOnlyValidators(),
+		expiryDiff:        newExpiryDiff(),
+		sovDiff:           newSubnetOnlyValidatorsDiff(),
+		subnetOwners:      make(map[ids.ID]fx.Owner),
+		subnetConversions: make(map[ids.ID]subnetConversion),
 	}, nil
 }
 
@@ -117,6 +123,14 @@ func (d *diff) SetFeeState(feeState gas.State) {
 	d.feeState = feeState
 }
 
+func (d *diff) GetSoVExcess() gas.Gas {
+	return d.sovExcess
+}
+
+func (d *diff) SetSoVExcess(excess gas.Gas) {
+	d.sovExcess = excess
+}
+
 func (d *diff) GetAccruedFees() uint64 {
 	return d.accruedFees
 }
@@ -184,6 +198,70 @@ func (d *diff) DeleteExpiry(entry ExpiryEntry) {
 	d.expiryDiff.DeleteExpiry(entry)
 }
 
+func (d *diff) GetActiveSubnetOnlyValidatorsIterator() (iterator.Iterator[SubnetOnlyValidator], error) {
+	parentState, ok := d.stateVersions.GetState(d.parentID)
+	if !ok {
+		return nil, fmt.Errorf("%w: %s", ErrMissingParentState, d.parentID)
+	}
+
+	parentIterator, err := parentState.GetActiveSubnetOnlyValidatorsIterator()
+	if err != nil {
+		return nil, err
+	}
+
+	return d.sovDiff.getActiveSubnetOnlyValidatorsIterator(parentIterator), nil
+}
+
+func (d *diff) NumActiveSubnetOnlyValidators() int {
+	return d.parentActiveSOVs + d.sovDiff.numAddedActive
+}
+
+func (d *diff) WeightOfSubnetOnlyValidators(subnetID ids.ID) (uint64, error) {
+	if weight, modified := d.sovDiff.modifiedTotalWeight[subnetID]; modified {
+		return weight, nil
+	}
+
+	parentState, ok := d.stateVersions.GetState(d.parentID)
+	if !ok {
+		return 0, fmt.Errorf("%w: %s", ErrMissingParentState, d.parentID)
+	}
+
+	return parentState.WeightOfSubnetOnlyValidators(subnetID)
+}
+
+func (d *diff) GetSubnetOnlyValidator(validationID ids.ID) (SubnetOnlyValidator, error) {
+	if sov, modified := d.sovDiff.modified[validationID]; modified {
+		if sov.Weight == 0 {
+			return SubnetOnlyValidator{}, database.ErrNotFound
+		}
+		return sov, nil
+	}
+
+	parentState, ok := d.stateVersions.GetState(d.parentID)
+	if !ok {
+		return SubnetOnlyValidator{}, fmt.Errorf("%w: %s", ErrMissingParentState, d.parentID)
+	}
+
+	return parentState.GetSubnetOnlyValidator(validationID)
+}
+
+func (d *diff) HasSubnetOnlyValidator(subnetID ids.ID, nodeID ids.NodeID) (bool, error) {
+	if has, modified := d.sovDiff.hasSubnetOnlyValidator(subnetID, nodeID); modified {
+		return has, nil
+	}
+
+	parentState, ok := d.stateVersions.GetState(d.parentID)
+	if !ok {
+		return false, fmt.Errorf("%w: %s", ErrMissingParentState, d.parentID)
+	}
+
+	return parentState.HasSubnetOnlyValidator(subnetID, nodeID)
+}
+
+func (d *diff) PutSubnetOnlyValidator(sov SubnetOnlyValidator) error {
+	return d.sovDiff.putSubnetOnlyValidator(d, sov)
+}
+
 func (d *diff) GetCurrentValidator(subnetID ids.ID, nodeID ids.NodeID) (*Staker, error) {
 	// If the validator was modified in this diff, return the modified
 	// validator.
@@ -357,23 +435,24 @@ func (d *diff) SetSubnetOwner(subnetID ids.ID, owner fx.Owner) {
 	d.subnetOwners[subnetID] = owner
 }
 
-func (d *diff) GetSubnetManager(subnetID ids.ID) (ids.ID, []byte, error) {
-	if manager, exists := d.subnetManagers[subnetID]; exists {
-		return manager.ChainID, manager.Addr, nil
+func (d *diff) GetSubnetConversion(subnetID ids.ID) (ids.ID, ids.ID, []byte, error) {
+	if conversion, exists := d.subnetConversions[subnetID]; exists {
+		return conversion.ConversionID, conversion.ChainID, conversion.Addr, nil
 	}
 
 	// If the subnet manager was not assigned in this diff, ask the parent state.
 	parentState, ok := d.stateVersions.GetState(d.parentID)
 	if !ok {
-		return ids.Empty, nil, ErrMissingParentState
+		return ids.Empty, ids.Empty, nil, ErrMissingParentState
 	}
-	return parentState.GetSubnetManager(subnetID)
+	return parentState.GetSubnetConversion(subnetID)
 }
 
-func (d *diff) SetSubnetManager(subnetID ids.ID, chainID ids.ID, addr []byte) {
-	d.subnetManagers[subnetID] = chainIDAndAddr{
-		ChainID: chainID,
-		Addr:    addr,
+func (d *diff) SetSubnetConversion(subnetID ids.ID, conversionID ids.ID, chainID ids.ID, addr []byte) {
+	d.subnetConversions[subnetID] = subnetConversion{
+		ConversionID: conversionID,
+		ChainID:      chainID,
+		Addr:         addr,
 	}
 }
 
@@ -485,6 +564,7 @@ func (d *diff) DeleteUTXO(utxoID ids.ID) {
 func (d *diff) Apply(baseState Chain) error {
 	baseState.SetTimestamp(d.timestamp)
 	baseState.SetFeeState(d.feeState)
+	baseState.SetSoVExcess(d.sovExcess)
 	baseState.SetAccruedFees(d.accruedFees)
 	for subnetID, supply := range d.currentSupply {
 		baseState.SetCurrentSupply(subnetID, supply)
@@ -496,6 +576,26 @@ func (d *diff) Apply(baseState Chain) error {
 			baseState.DeleteExpiry(entry)
 		}
 	}
+	// Ensure that all sov deletions happen before any sov additions. This
+	// ensures that a subnetID+nodeID pair that was deleted and then re-added in
+	// a single diff can't get reordered into the addition happening first;
+	// which would return an error.
+	for _, sov := range d.sovDiff.modified {
+		if sov.Weight != 0 {
+			continue
+		}
+		if err := baseState.PutSubnetOnlyValidator(sov); err != nil {
+			return err
+		}
+	}
+	for _, sov := range d.sovDiff.modified {
+		if sov.Weight == 0 {
+			continue
+		}
+		if err := baseState.PutSubnetOnlyValidator(sov); err != nil {
+			return err
+		}
+	}
 	for _, subnetValidatorDiffs := range d.currentStakerDiffs.validatorDiffs {
 		for _, validatorDiff := range subnetValidatorDiffs {
 			switch validatorDiff.validatorStatus {
@@ -576,8 +676,8 @@ func (d *diff) Apply(baseState Chain) error {
 	for subnetID, owner := range d.subnetOwners {
 		baseState.SetSubnetOwner(subnetID, owner)
 	}
-	for subnetID, manager := range d.subnetManagers {
-		baseState.SetSubnetManager(subnetID, manager.ChainID, manager.Addr)
+	for subnetID, conversion := range d.subnetConversions {
+		baseState.SetSubnetConversion(subnetID, conversion.ConversionID, conversion.ChainID, conversion.Addr)
 	}
 	return nil
 }