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

@@ -623,14 +623,6 @@ func (a *NodeApi) PeersConnected(w http.ResponseWriter, _ *http.Request) error {
 	return nil
 }
 
-func (a *NodeApi) PeersSuspended(w http.ResponseWriter, _ *http.Request) error {
-	rs := a.app.PeersSuspended()
-	if err := trySendJSON(w, rs); err != nil {
-		return errors.Wrap(err, "PeersSuspended")
-	}
-	return nil
-}
-
 func (a *NodeApi) PeersBlackListed(w http.ResponseWriter, _ *http.Request) error {
 	rs := a.app.PeersBlackListed()
 	if err := trySendJSON(w, rs); err != nil {
@@ -906,13 +898,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 +920,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/api/peers.go

@@ -26,12 +26,8 @@ type PeersKnown struct {
 // PeersAll is a list of all known not banned, not suspended and not blacklisted peers with a publicly
 // available declared address.
 func (a *App) PeersAll() (PeersKnown, error) {
-	suspended := a.peers.Suspended()
 	blackList := a.peers.BlackList()
-	restrictedIPsMap := make(map[string]struct{}, len(suspended)+len(blackList))
-	for _, suspendedPeer := range suspended {
-		restrictedIPsMap[suspendedPeer.IP.String()] = struct{}{}
-	}
+	restrictedIPsMap := make(map[string]struct{}, len(blackList))
 	for _, blackListedPeer := range blackList {
 		restrictedIPsMap[blackListedPeer.IP.String()] = struct{}{}
 	}
@@ -144,21 +140,6 @@ type RestrictedPeerInfo struct {
 	Reason    string `json:"reason,omitempty"`
 }
 
-func (a *App) PeersSuspended() []RestrictedPeerInfo {
-	suspended := a.peers.Suspended()
-
-	out := make([]RestrictedPeerInfo, 0, len(suspended))
-	for _, p := range suspended {
-		out = append(out, RestrictedPeerInfo{
-			Hostname:  "/" + p.IP.String(),
-			Timestamp: p.RestrictTimestampMillis,
-			Reason:    p.Reason,
-		})
-	}
-
-	return out
-}
-
 func (a *App) PeersBlackListed() []RestrictedPeerInfo {
 	blackList := a.peers.BlackList()
 

pkg/api/peers_test.go

@@ -33,50 +33,6 @@ func TestApp_PeersKnown(t *testing.T) {
 	require.Len(t, rs2.Peers, 1)
 }
 
-func TestApp_PeersSuspended(t *testing.T) {
-	peerManager := peers.NewMockPeerManager(t)
-
-	now := time.Now()
-	cfg := &settings.BlockchainSettings{
-		FunctionalitySettings: settings.FunctionalitySettings{
-			GenerationPeriod: 0,
-		},
-	}
-
-	ips := []string{"13.3.4.1", "5.3.6.7"}
-	testData := []storage.SuspendedPeer{
-		{
-			IP:                      storage.IPFromString(ips[0]),
-			RestrictTimestampMillis: now.Add(time.Minute).UnixMilli(),
-			RestrictDuration:        time.Minute,
-			Reason:                  "some reason #1",
-		},
-		{
-			IP:                      storage.IPFromString(ips[1]),
-			RestrictTimestampMillis: now.Add(2 * time.Minute).UnixMilli(),
-			RestrictDuration:        time.Minute,
-			Reason:                  "some reason #2",
-		},
-	}
-
-	peerManager.EXPECT().Suspended().Return(testData)
-
-	app, err := NewApp("key", nil, services.Services{Peers: peerManager}, cfg)
-	require.NoError(t, err)
-
-	suspended := app.PeersSuspended()
-
-	for i, actual := range suspended {
-		p := testData[i]
-		expected := RestrictedPeerInfo{
-			Hostname:  "/" + ips[i],
-			Timestamp: p.RestrictTimestampMillis,
-			Reason:    p.Reason,
-		}
-		assert.Equal(t, expected, actual)
-	}
-}
-
 func TestApp_PeersBlackList(t *testing.T) {
 	peerManager := peers.NewMockPeerManager(t)
 

pkg/api/routes.go

@@ -152,7 +152,6 @@ func (a *NodeApi) routes(opts *RunOptions) (chi.Router, error) {
 		r.Route("/peers", func(r chi.Router) {
 			r.Get("/all", wrapper(a.PeersAll))
 			r.Get("/connected", wrapper(a.PeersConnected))
-			r.Get("/suspended", wrapper(a.PeersSuspended))
 			r.Get("/blacklisted", wrapper(a.PeersBlackListed))
 
 			rAuth := r.With(checkAuthMiddleware)

pkg/node/fsm/fsm_common.go

@@ -96,12 +96,9 @@ func syncWithNewPeer(state State, baseInfo BaseInfo, p peer.Peer) (State, Async,
 		lastSignatures,
 		baseInfo.enableLightMode,
 	)
-	c := conf{
-		peerSyncWith: p,
-		timeout:      defaultSyncTimeout,
-	}
 	baseInfo.logger.Debug("Starting synchronization with peer", "state", state.String(), "peer", p.ID())
 	baseInfo.syncPeer.SetPeer(p)
+	c := conf{timeout: defaultSyncTimeout}
 	return &SyncState{
 		baseInfo: baseInfo,
 		conf:     c.Now(baseInfo.tm),

pkg/node/fsm/idle_state.go

@@ -2,6 +2,7 @@ package fsm
 
 import (
 	"context"
+	"log/slog"
 
 	"github.com/pkg/errors"
 	"github.com/qmuntal/stateless"
@@ -49,6 +50,8 @@ func (a *IdleState) StartMining() (State, Async, error) {
 func (a *IdleState) MinedBlock(
 	block *proto.Block, limits proto.MiningLimits, keyPair proto.KeyPair, vrf []byte,
 ) (State, Async, error) {
+	a.baseInfo.logger.Info("New block mined", slog.String("state", a.String()),
+		slog.String("blockID", block.ID.String()))
 	newA, ok := newNGState(a.baseInfo).(*NGState)
 	if !ok {
 		return a, nil, a.Errorf(errors.Errorf("unexpected type '%T' expected '*NGState'", a.baseInfo))