Burn deposit

itests/config/blockchain.go

@@ -115,6 +115,8 @@ func NewBlockchainConfig(options ...BlockchainOption) (*BlockchainConfig, error)
 	bs.BlockRewardTerm = defaultBlockRewardTerm
 	bs.MinXTNBuyBackPeriod = defaultMinXTNBuyBackPeriod
 	bs.LightNodeBlockFieldsAbsenceInterval = lightNodeBlockFieldsAbsenceInterval
+	bs.GenerationPeriod = defaultGenerationPeriod
+	bs.MaxEndorsements = defaultMaxEndorsements
 
 	cfg := &BlockchainConfig{
 		Settings:      bs,

itests/config/genesis_settings.go

@@ -38,6 +38,9 @@ const (
 	defaultQuorum                  = 1 // Default quorum is 1 to allow mining without waiting for testnet client.
 
 	lightNodeBlockFieldsAbsenceInterval = 2
+
+	defaultGenerationPeriod = 5
+	defaultMaxEndorsements  = 3
 )
 
 var (

pkg/api/node_api.go

@@ -906,13 +906,6 @@ func (a *NodeApi) snapshotStateHash(w http.ResponseWriter, r *http.Request) erro
 	return nil
 }
 
-// TODO: Move JSON tags to GeneratorInfo structure.
-type generatorInfo struct {
-	Address       string `json:"address"`
-	Balance       uint64 `json:"balance"`
-	TransactionID string `json:"transactionID"`
-}
-
 func (a *NodeApi) GeneratorsAt(w http.ResponseWriter, r *http.Request) error {
 	heightStr := chi.URLParam(r, "height")
 	height, err := strconv.ParseUint(heightStr, 10, 64)
@@ -935,32 +928,31 @@ func (a *NodeApi) GeneratorsAt(w http.ResponseWriter, r *http.Request) error {
 	if err != nil {
 		return err
 	}
-
-	infos := make([]generatorInfo, len(gs))
-	for i, g := range gs {
-		infos[i] = generatorInfo{
-			Address:       g.Address().String(),
-			Balance:       g.GenerationBalance(),
-			TransactionID: "", // It was decided to leave it empty.
-		}
-	}
-	return trySendJSON(w, infos)
+	return trySendJSON(w, gs)
 }
 
 func (a *NodeApi) FinalizedHeight(w http.ResponseWriter, _ *http.Request) error {
 	h, err := a.state.LastFinalizedHeight()
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get finalized block height: %w", err)
 	}
 	return trySendJSON(w, map[string]uint64{"height": h})
 }
 
 func (a *NodeApi) FinalizedHeader(w http.ResponseWriter, _ *http.Request) error {
-	blockHeader, err := a.app.state.LastFinalizedBlock()
+	fh, err := a.state.LastFinalizedHeight()
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get finalized block height: %w", err)
+	}
+	header, err := a.app.state.LastFinalizedBlock()
+	if err != nil {
+		return fmt.Errorf("failed to get finalized block header: %w", err)
+	}
+	b, err := newAPIBlockFromHeader(*header, a.app.scheme(), fh)
+	if err != nil {
+		return fmt.Errorf("failed to get finalized block: %w", err)
 	}
-	return trySendJSON(w, blockHeader)
+	return trySendJSON(w, b)
 }
 
 type signTxEnvelope struct {

pkg/node/fsm/ng_state.go

@@ -258,16 +258,29 @@ func (a *NGState) endorseParentWithEachKey(
 	block *proto.Block,
 	blockHeight proto.Height,
 ) error {
-	activationHeight, err := a.baseInfo.storage.ActivationHeight(int16(settings.DeterministicFinality))
-	if err != nil {
-		return a.Errorf(errors.Wrapf(err, "failed to get activation height for finality %s", block.BlockID()))
+	// Check current generators set.
+	gs, err := a.baseInfo.storage.CommittedGenerators(blockHeight)
+	if err != nil && !errors.Is(err, state.ErrNoGeneratorsSet) {
+		return a.Errorf(errors.Wrapf(err, "failed to get generators for block '%s'", block.BlockID()))
 	}
-
-	periodStart, err := state.CurrentGenerationPeriodStart(activationHeight, blockHeight, a.baseInfo.generationPeriod)
-	if err != nil {
-		return a.Errorf(errors.Wrapf(err, "failed to get current generation period, block %s", block.BlockID()))
+	if errors.Is(err, state.ErrNoGeneratorsSet) || len(gs) == 0 {
+		slog.Debug("Generator set is empty, skipping block endorsement", slog.Uint64("height", blockHeight))
+		return nil
 	}
 
+	// Following variables are used for logging only.
+	var activationHeight proto.Height
+	var periodStart uint32
+	if slog.Default().Enabled(context.Background(), slog.LevelDebug) {
+		activationHeight, err = a.baseInfo.storage.ActivationHeight(int16(settings.DeterministicFinality))
+		if err != nil {
+			return a.Errorf(errors.Wrapf(err, "failed to get activation height for finality %s", block.BlockID()))
+		}
+		periodStart, err = state.CurrentGenerationPeriodStart(activationHeight, blockHeight, a.baseInfo.generationPeriod)
+		if err != nil {
+			return a.Errorf(errors.Wrapf(err, "failed to get current generation period, block %s", block.BlockID()))
+		}
+	}
 	for i := range sks {
 		sk := sks[i]
 		pk, pkErr := sk.PublicKey()
@@ -278,13 +291,13 @@ func (a *NGState) endorseParentWithEachKey(
 			slog.Int("SeedIndex", i), slog.String("BLS PublicKey", pk.String()),
 			slog.Any("BlockID", block.BlockID()), slog.Any("GenerationPeriodStart", periodStart))
 
-		g, gErr := a.baseInfo.storage.FindGenerator(state.ByBLSPublicKey(pk))
+		g, gErr := a.baseInfo.storage.FindGenerator(blockHeight, state.ByBLSPublicKey(pk))
 		if gErr != nil {
 			slog.Warn("Wallet's BLS public key is not in the generators set",
 				slog.String("BLS PublicKey", pk.String()), logging.Error(gErr))
 			continue
 		}
-		if g.GenerationBalance() == 0 {
+		if g.Balance == 0 {
 			slog.Debug("Wallet's BLS public key has insufficient generation balance",
 				slog.Int("SeedIndex", i), slog.String("BLS PublicKey", pk.String()),
 				slog.Any("BlockID", block.BlockID()), slog.Any("GenerationPeriodStart", periodStart))
@@ -316,12 +329,15 @@ func (a *NGState) BlockEndorsement(blockEndorsement *proto.BlockEndorsement) (St
 	}
 
 	top := a.baseInfo.storage.TopBlock()
-
+	h, err := a.baseInfo.storage.Height()
+	if err != nil {
+		return a, nil, a.Errorf(errors.Wrapf(err, "failed to retrieve current height"))
+	}
 	generatorIndex, err := safecast.Convert[uint32](blockEndorsement.EndorserIndex)
 	if err != nil {
 		return a, nil, a.Errorf(errors.Wrapf(err, "failed to convert endorser index to uint32"))
 	}
-	gi, err := a.baseInfo.storage.FindGenerator(state.ByIndex(generatorIndex))
+	gi, err := a.baseInfo.storage.FindGenerator(h, state.ByIndex(generatorIndex))
 	if err != nil {
 		return a, nil, a.Errorf(errors.Wrapf(err, "failed to find generator by index"))
 	}
@@ -334,8 +350,8 @@ func (a *NGState) BlockEndorsement(blockEndorsement *proto.BlockEndorsement) (St
 		return a, nil, a.Errorf(errors.Wrapf(err, "failed to get last finalized block header for endorser address"))
 	}
 	// TODO check if generator is in the generator set.
-	endorserPK := gi.BLSPublicKey()
-	balance := gi.GenerationBalance()
+	endorserPK := gi.BLSPublicKey
+	balance := gi.Balance
 	added, addErr := a.baseInfo.endorsements.Add(blockEndorsement, endorserPK,
 		localFinalizedHeight, localFinalizedBlockHeader.BlockID(), balance, top.Parent)
 	if addErr != nil {
@@ -457,7 +473,7 @@ func (a *NGState) MinedBlock(
 
 func (a *NGState) Endorse(parentBlockID proto.BlockID,
 	endorser state.GeneratorInfo, endorserSK bls.SecretKey) error {
-	endorserIndex := endorser.Index()
+	endorserIndex := endorser.Index
 	lastFinalizedHeight, err := a.baseInfo.storage.LastFinalizedHeight()
 	if err != nil {
 		return a.Errorf(errors.Wrap(err, "failed to get last finalized block height"))
@@ -514,10 +530,10 @@ func (a *NGState) addAndBroadcastOwnEndorsement(
 	top := a.baseInfo.storage.TopBlock()
 	added, addErr := a.baseInfo.endorsements.Add(
 		parentBlockEndorsement,
-		endorser.BLSPublicKey(),
+		endorser.BLSPublicKey,
 		lastFinalizedHeight,
 		lastFinalizedBlockID,
-		endorser.GenerationBalance(),
+		endorser.Balance,
 		top.Parent,
 	)
 	if addErr != nil {

pkg/node/fsm/sync_state.go

@@ -16,6 +16,7 @@ import (
 	"github.com/wavesplatform/gowaves/pkg/p2p/peer"
 	"github.com/wavesplatform/gowaves/pkg/p2p/peer/extension"
 	"github.com/wavesplatform/gowaves/pkg/proto"
+	"github.com/wavesplatform/gowaves/pkg/settings"
 	"github.com/wavesplatform/gowaves/pkg/state"
 	"github.com/wavesplatform/gowaves/pkg/types"
 )
@@ -200,22 +201,26 @@ func (a *SyncState) BlockSnapshot(
 func (a *SyncState) MinedBlock(
 	block *proto.Block, limits proto.MiningLimits, keyPair proto.KeyPair, vrf []byte,
 ) (State, Async, error) {
-	height, heightErr := a.baseInfo.storage.Height()
-	if heightErr != nil {
-		return a, nil, a.Errorf(heightErr)
+	height, err := a.baseInfo.storage.Height()
+	if err != nil {
+		return a, nil, a.Errorf(err)
+	}
+	ngActivated, err := a.baseInfo.storage.IsActiveAtHeight(int16(settings.NG), height)
+	if err != nil {
+		return a, nil, a.Errorf(err)
+	}
+	if ngActivated {
+		slog.Debug("Skipping mined block in Sync state because NG is already active", "state", a.String())
+		return a, nil, nil
 	}
 	metrics.BlockMined(block)
 	a.baseInfo.logger.Info("New block mined", "state", a.String(), "blockID", block.ID.String())
 
-	_, err := a.baseInfo.blocksApplier.Apply(
-		a.baseInfo.storage,
-		[]*proto.Block{block},
-	)
-	if err != nil {
-		slog.Warn("Failed to apply mined block", slog.String("state", a.String()), logging.Error(err))
+	if _, apErr := a.baseInfo.blocksApplier.Apply(a.baseInfo.storage, []*proto.Block{block}); apErr != nil {
+		slog.Warn("Failed to apply mined block", slog.String("state", a.String()), logging.Error(apErr))
 		return a, nil, nil // We've failed to apply mined block, it's not an error
 	}
-	metrics.BlockAppliedFromExtension(block, height+1)
+	metrics.BlockApplied(block, height+1)
 	a.baseInfo.scheduler.Reschedule()
 
 	// first we should send block

pkg/proto/finalization.go

@@ -58,8 +58,8 @@ func (msg *EndorsementCryptoMessage) Bytes() ([]byte, error) {
 // BlockEndorsement represents an endorsement of a block by a validator.
 type BlockEndorsement struct {
 	EndorserIndex        uint32        `json:"endorserIndex"`
-	FinalizedBlockID     BlockID       `json:"finalizedBlockID"`
-	FinalizedBlockHeight uint32        `json:"finalizedBlockHeight"`
+	FinalizedBlockID     BlockID       `json:"finalizedBlockId"`
+	FinalizedBlockHeight uint32        `json:"finalizedHeight"`
 	EndorsedBlockID      BlockID       `json:"endorsedBlockId"`
 	Signature            bls.Signature `json:"signature"`
 }
@@ -110,10 +110,10 @@ func (e *BlockEndorsement) ToProtobuf() (*g.EndorseBlock, error) {
 }
 
 type FinalizationVoting struct {
-	EndorserIndexes                []uint32           `json:"endorserIndexes"`
-	FinalizedBlockHeight           Height             `json:"finalizedBlockHeight"`
+	EndorserIndexes                []uint32           `json:"endorserIndexes,omitempty"`
+	FinalizedBlockHeight           Height             `json:"finalizedHeight"`
 	AggregatedEndorsementSignature bls.Signature      `json:"aggregatedEndorsementSignature"`
-	ConflictEndorsements           []BlockEndorsement `json:"conflictEndorsements"`
+	ConflictEndorsements           []BlockEndorsement `json:"conflictEndorsements,omitempty"`
 }
 
 // Validate checks that FinalizationVoting doesn't have any duplicate endorsers indexes.
@@ -137,6 +137,19 @@ func (f *FinalizationVoting) Validate() error {
 	return nil
 }
 
+// CheckSizes validates the sizes of finalization fields against the size of generator set.
+// The number of endorsements and conflicting endorsements must not exceed the generator set size.
+func (f *FinalizationVoting) CheckSizes(generatorSetSize int) error {
+	if ces := len(f.ConflictEndorsements); ces > generatorSetSize {
+		return fmt.Errorf("conflicting endorsements count %d exceeds generator set size %d",
+			ces, generatorSetSize)
+	}
+	if eis := len(f.EndorserIndexes); eis > generatorSetSize {
+		return fmt.Errorf("endorsements count %d exceeds generator set size %d", eis, generatorSetSize)
+	}
+	return nil
+}
+
 func (f *FinalizationVoting) Marshal() ([]byte, error) {
 	endBlockProto, err := f.ToProtobuf()
 	if err != nil {