remove active node registry when participation score reach 0 (#1328)

* remove active node registry when participation score reach 0

* calculateNodeOrder divide by 1, it is not used anymore, will be removed in new blocksmith selection implementation #1190

* omit division

* fix tests

* remove outdated test

Author: andy-shi88

core/smith/strategy/blocksmithStrategyMain_test.go

@@ -174,83 +174,6 @@ func (*mockActiveNodeRegistryCacheSuccessWithContent) GetAllItems(item interface
 	return nil
 }
 
-func TestBlocksmithService_GetBlocksmiths(t *testing.T) {
-	type fields struct {
-		QueryExecutor            query.ExecutorInterface
-		NodeRegistrationQuery    query.NodeRegistrationQueryInterface
-		Logger                   *log.Logger
-		SortedBlocksmiths        []*model.Blocksmith
-		SortedBlocksmithsMap     map[string]*int64
-		SortedBlocksmithsMapLock sync.RWMutex
-		ActiveNodeRegistryCache  storage.CacheStorageInterface
-	}
-	type args struct {
-		block *model.Block
-	}
-	tests := []struct {
-		name    string
-		fields  fields
-		args    args
-		want    []*model.Blocksmith
-		wantErr bool
-	}{
-		{
-			name: "success - no blocksmiths",
-			fields: fields{
-				QueryExecutor:           &mockQueryGetBlocksmithsMainSuccessNoBlocksmith{},
-				NodeRegistrationQuery:   query.NewNodeRegistrationQuery(),
-				ActiveNodeRegistryCache: &mockActiveNodeRegistryCacheSuccess{},
-
-				Logger: log.New(),
-			},
-			args:    args{&model.Block{}},
-			wantErr: false,
-			want:    nil,
-		},
-		{
-			name: "success - with blocksmiths",
-			fields: fields{
-				QueryExecutor:           &mockQueryGetBlocksmithsMainSuccessWithBlocksmith{},
-				NodeRegistrationQuery:   query.NewNodeRegistrationQuery(),
-				Logger:                  log.New(),
-				ActiveNodeRegistryCache: &mockActiveNodeRegistryCacheSuccessWithContent{},
-			},
-			args:    args{mockBlock},
-			wantErr: false,
-			want: []*model.Blocksmith{
-				{
-					NodeID:        bssMockBlocksmiths[0].NodeID,
-					BlockSeed:     -7765827254621503546,
-					NodeOrder:     new(big.Int).SetInt64(13195850646937615),
-					Score:         bssMockBlocksmiths[0].Score,
-					NodePublicKey: bssMockBlocksmiths[0].NodePublicKey,
-				},
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			bss := &BlocksmithStrategyMain{
-				QueryExecutor:           tt.fields.QueryExecutor,
-				NodeRegistrationQuery:   tt.fields.NodeRegistrationQuery,
-				Logger:                  tt.fields.Logger,
-				ActiveNodeRegistryCache: tt.fields.ActiveNodeRegistryCache,
-				SortedBlocksmiths:       tt.fields.SortedBlocksmiths,
-				SortedBlocksmithsMap:    tt.fields.SortedBlocksmithsMap,
-				SortedBlocksmithsLock:   tt.fields.SortedBlocksmithsMapLock,
-			}
-			got, err := bss.GetBlocksmiths(tt.args.block)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("GetBlocksmiths() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("GetBlocksmiths() got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
 func TestBlocksmithService_GetSortedBlocksmiths(t *testing.T) {
 	type fields struct {
 		QueryExecutor            query.ExecutorInterface

core/smith/strategy/blocksmithStrategySpine_test.go

@@ -219,98 +219,6 @@ func (*mockQueryGetBlocksmithsSpineSuccessNoBlocksmith) ExecuteSelectRow(qStr st
 	return db.QueryRow(qStr), nil
 }
 
-func TestBlocksmithStrategySpine_GetBlocksmiths(t *testing.T) {
-	type fields struct {
-		QueryExecutor        query.ExecutorInterface
-		SpinePublicKeyQuery  query.SpinePublicKeyQueryInterface
-		Logger               *log.Logger
-		SortedBlocksmiths    []*model.Blocksmith
-		LastSortedBlockID    int64
-		SortedBlocksmithsMap map[string]*int64
-	}
-	type args struct {
-		block *model.Block
-	}
-	tests := []struct {
-		name    string
-		fields  fields
-		args    args
-		want    []*model.Blocksmith
-		wantErr bool
-	}{
-		{
-			name: "GetBlocksmiths:success",
-			fields: fields{
-				QueryExecutor:        &mockQueryGetBlocksmithsSpineSuccessWithBlocksmith{},
-				SpinePublicKeyQuery:  query.NewSpinePublicKeyQuery(),
-				Logger:               log.New(),
-				SortedBlocksmiths:    nil,
-				SortedBlocksmithsMap: make(map[string]*int64),
-				LastSortedBlockID:    1,
-			},
-			args:    args{mockBlock},
-			wantErr: false,
-			want: []*model.Blocksmith{
-				{
-					NodeID:        bssMockBlocksmiths[0].NodeID,
-					BlockSeed:     -1965565459747201754,
-					NodeOrder:     new(big.Int).SetInt64(28),
-					Score:         big.NewInt(constant.DefaultParticipationScore),
-					NodePublicKey: bssMockBlocksmiths[0].NodePublicKey,
-				},
-			},
-		},
-		{
-			name: "GetBlocksmiths:fail-{sqlSelectErr}",
-			fields: fields{
-				QueryExecutor:        &mockQueryGetBlocksmithsSpineFail{},
-				SpinePublicKeyQuery:  query.NewSpinePublicKeyQuery(),
-				Logger:               log.New(),
-				SortedBlocksmiths:    nil,
-				SortedBlocksmithsMap: make(map[string]*int64),
-				LastSortedBlockID:    1,
-			},
-			args:    args{mockBlock},
-			wantErr: true,
-			want:    nil,
-		},
-		{
-			name: "GetBlocksmiths:fail-{noSpinePublicKeyFound}",
-			fields: fields{
-				QueryExecutor:        &mockQueryGetBlocksmithsSpineSuccessNoBlocksmith{},
-				SpinePublicKeyQuery:  query.NewSpinePublicKeyQuery(),
-				Logger:               log.New(),
-				SortedBlocksmiths:    nil,
-				SortedBlocksmithsMap: make(map[string]*int64),
-				LastSortedBlockID:    1,
-			},
-			args:    args{mockBlock},
-			wantErr: false,
-			want:    nil,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			bss := &BlocksmithStrategySpine{
-				QueryExecutor:        tt.fields.QueryExecutor,
-				SpinePublicKeyQuery:  tt.fields.SpinePublicKeyQuery,
-				Logger:               tt.fields.Logger,
-				SortedBlocksmiths:    tt.fields.SortedBlocksmiths,
-				LastSortedBlockID:    tt.fields.LastSortedBlockID,
-				SortedBlocksmithsMap: tt.fields.SortedBlocksmithsMap,
-			}
-			got, err := bss.GetBlocksmiths(tt.args.block)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("BlocksmithStrategySpine.GetBlocksmiths() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("BlocksmithStrategySpine.GetBlocksmiths() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
 func TestBlocksmithStrategySpine_SortBlocksmiths(t *testing.T) {
 	type fields struct {
 		QueryExecutor        query.ExecutorInterface

core/util/blockUtil.go

@@ -87,7 +87,7 @@ func IsBlockIDExist(blockIds []int64, expectedBlockID int64) bool {
 // CalculateNodeOrder calculate the Node order parameter, used to sort/select the group of blocksmith rewarded for a given block
 func CalculateNodeOrder(score *big.Int, blockSeed, nodeID int64) *big.Int {
 	prn := crypto.PseudoRandomGenerator(uint64(nodeID), uint64(blockSeed), crypto.PseudoRandomSha3256)
-	return new(big.Int).Div(new(big.Int).SetUint64(prn), score)
+	return new(big.Int).SetUint64(prn)
 }
 
 func IsGenesis(previousBlockID int64, block *model.Block) bool {

core/util/blockUtil_test.go

@@ -236,7 +236,7 @@ func TestCalculateNodeOrder(t *testing.T) {
 				blockSeed: 1000,
 				nodeID:    int64(1000),
 			},
-			want: "7357219233906154",
+			want: "7357219233906154824",
 		},
 		{
 			name: "CalculateNodeOrder:success2",
@@ -245,7 +245,7 @@ func TestCalculateNodeOrder(t *testing.T) {
 				blockSeed: 3000,
 				nodeID:    int64(10),
 			},
-			want: "2461325401382821",
+			want: "4922650802765643438",
 		},
 	}
 	for _, tt := range tests {