Merge branch 'master' into forkchain

Author: CoderZhi

action/protocol/rewarding/protocol.go

@@ -111,6 +111,8 @@ func (p *Protocol) CreatePreStates(ctx context.Context, sm protocol.StateManager
 		return p.migrateValueGreenland(ctx, sm)
 	case g.KamchatkaBlockHeight:
 		return p.setFoundationBonusExtension(ctx, sm)
+	case g.ToBeEnabledBlockHeight: // todo: change to wake block height
+		return p.SetReward(ctx, sm, g.WakeBlockReward(), true)
 	}
 	return nil
 }

action/protocol/rewarding/reward_test.go

@@ -35,56 +35,89 @@ import (
 )
 
 func TestProtocol_GrantBlockReward(t *testing.T) {
-	testProtocol(t, func(t *testing.T, ctx context.Context, sm protocol.StateManager, p *Protocol) {
-		blkCtx, ok := protocol.GetBlockCtx(ctx)
-		require.True(t, ok)
-
-		// Grant block reward will fail because of no available balance
-		_, err := p.GrantBlockReward(ctx, sm)
-		require.Error(t, err)
-
-		_, err = p.Deposit(ctx, sm, big.NewInt(200), iotextypes.TransactionLogType_DEPOSIT_TO_REWARDING_FUND)
-		require.NoError(t, err)
-
-		// Grant block reward
-		rewardLog, err := p.GrantBlockReward(ctx, sm)
-		require.NoError(t, err)
-		require.Equal(t, p.addr.String(), rewardLog.Address)
-		var rl rewardingpb.RewardLog
-		require.NoError(t, proto.Unmarshal(rewardLog.Data, &rl))
-		require.Equal(t, rewardingpb.RewardLog_BLOCK_REWARD, rl.Type)
-		require.Equal(t, "10", rl.Amount)
-
-		availableBalance, _, err := p.AvailableBalance(ctx, sm)
-		require.NoError(t, err)
-		assert.Equal(t, big.NewInt(190), availableBalance)
-		// Operator shouldn't get reward
-		unclaimedBalance, _, err := p.UnclaimedBalance(ctx, sm, blkCtx.Producer)
-		require.NoError(t, err)
-		assert.Equal(t, big.NewInt(0), unclaimedBalance)
-		// Beneficiary should get reward
-		unclaimedBalance, _, err = p.UnclaimedBalance(ctx, sm, identityset.Address(0))
-		require.NoError(t, err)
-		assert.Equal(t, big.NewInt(10), unclaimedBalance)
-
-		// Grant the same block reward again will fail
-		_, err = p.GrantBlockReward(ctx, sm)
-		require.Error(t, err)
-
-		// Grant with priority fee after VanuatuBlockHeight
-		blkCtx.AccumulatedTips = *big.NewInt(5)
-		blkCtx.BlockHeight = genesis.TestDefault().VanuatuBlockHeight
-		ctx = protocol.WithFeatureCtx(protocol.WithBlockCtx(ctx, blkCtx))
-		rewardLog, err = p.GrantBlockReward(ctx, sm)
-		require.NoError(t, err)
-		rls, err := UnmarshalRewardLog(rewardLog.Data)
-		require.NoError(t, err)
-		require.Len(t, rls.Logs, 2)
-		require.Equal(t, rewardingpb.RewardLog_BLOCK_REWARD, rls.Logs[0].Type)
-		require.Equal(t, "10", rls.Logs[0].Amount)
-		require.Equal(t, rewardingpb.RewardLog_PRIORITY_BONUS, rls.Logs[1].Type)
-		require.Equal(t, blkCtx.AccumulatedTips.String(), rls.Logs[1].Amount)
-	}, false)
+	req := require.New(t)
+	for _, tv := range []struct {
+		blockReward *big.Int
+		deposit     *big.Int
+		isWakeBlock bool
+	}{
+		{big.NewInt(10), big.NewInt(200), false},
+		{big.NewInt(48), big.NewInt(300), true},
+	} {
+		testProtocol(t, func(t *testing.T, ctx context.Context, sm protocol.StateManager, p *Protocol) {
+			if tv.isWakeBlock {
+				g := genesis.MustExtractGenesisContext(ctx)
+				g.WakeBlockRewardStr = tv.blockReward.String()
+				wakeBlockCtx := genesis.WithGenesisContext(protocol.WithBlockCtx(ctx, protocol.BlockCtx{
+					BlockHeight: genesis.TestDefault().ToBeEnabledBlockHeight,
+				}), g)
+				req.NoError(p.CreatePreStates(wakeBlockCtx, sm))
+			}
+			// verify block reward
+			br, err := p.BlockReward(ctx, sm)
+			req.NoError(err)
+			req.Equal(tv.blockReward, br)
+			// Grant block reward will fail because of no available balance
+			_, err = p.GrantBlockReward(ctx, sm)
+			req.Error(err)
+
+			_, err = p.Deposit(ctx, sm, tv.deposit, iotextypes.TransactionLogType_DEPOSIT_TO_REWARDING_FUND)
+			req.NoError(err)
+
+			// Grant block reward
+			rewardLog, err := p.GrantBlockReward(ctx, sm)
+			req.NoError(err)
+			req.Equal(p.addr.String(), rewardLog.Address)
+			var rl rewardingpb.RewardLog
+			req.NoError(proto.Unmarshal(rewardLog.Data, &rl))
+			req.Equal(rewardingpb.RewardLog_BLOCK_REWARD, rl.Type)
+			req.Equal(tv.blockReward.String(), rl.Amount)
+
+			availableBalance, _, err := p.AvailableBalance(ctx, sm)
+			req.NoError(err)
+			req.Equal(tv.deposit.Sub(tv.deposit, tv.blockReward), availableBalance)
+			// Operator shouldn't get reward
+			blkCtx := protocol.MustGetBlockCtx(ctx)
+			unclaimedBalance, _, err := p.UnclaimedBalance(ctx, sm, blkCtx.Producer)
+			req.NoError(err)
+			req.Equal(big.NewInt(0), unclaimedBalance)
+			// Beneficiary should get reward
+			unclaimedBalance, _, err = p.UnclaimedBalance(ctx, sm, identityset.Address(0))
+			req.NoError(err)
+			req.Equal(tv.blockReward, unclaimedBalance)
+
+			// Grant the same block reward again will fail
+			_, err = p.GrantBlockReward(ctx, sm)
+			req.Error(err)
+
+			// Grant with priority fee after VanuatuBlockHeight
+			blkCtx.AccumulatedTips = *big.NewInt(5)
+			blkCtx.BlockHeight = genesis.TestDefault().VanuatuBlockHeight
+			ctx = protocol.WithFeatureCtx(protocol.WithBlockCtx(ctx, blkCtx))
+			tLog, err := DepositGas(ctx, sm, nil, protocol.PriorityFeeOption(&blkCtx.AccumulatedTips))
+			req.NoError(err)
+			req.Equal(tLog[0].Type, iotextypes.TransactionLogType_PRIORITY_FEE)
+			req.Equal(&blkCtx.AccumulatedTips, tLog[0].Amount)
+			rewardLog, err = p.GrantBlockReward(ctx, sm)
+			req.NoError(err)
+			rls, err := UnmarshalRewardLog(rewardLog.Data)
+			req.NoError(err)
+			req.Len(rls.Logs, 2)
+			req.Equal(rewardingpb.RewardLog_BLOCK_REWARD, rls.Logs[0].Type)
+			req.Equal(tv.blockReward.String(), rls.Logs[0].Amount)
+			req.Equal(rewardingpb.RewardLog_PRIORITY_BONUS, rls.Logs[1].Type)
+			req.Equal(blkCtx.AccumulatedTips.String(), rls.Logs[1].Amount)
+
+			// check available and receiver balance
+			availableBalance, _, err = p.AvailableBalance(ctx, sm)
+			req.NoError(err)
+			req.Equal(tv.deposit.Sub(tv.deposit, tv.blockReward), availableBalance)
+			unclaimedBalance, _, err = p.UnclaimedBalance(ctx, sm, identityset.Address(0))
+			req.NoError(err)
+			tv.blockReward.Lsh(tv.blockReward, 1)
+			req.Equal(tv.blockReward.Add(tv.blockReward, &blkCtx.AccumulatedTips), unclaimedBalance)
+		}, false)
+	}
 }
 
 func TestProtocol_GrantEpochReward(t *testing.T) {

blockchain/genesis/genesis.go

@@ -182,6 +182,7 @@ func defaultConfig() Genesis {
 			FoundationBonusP2StartEpoch:    9698,
 			FoundationBonusP2EndEpoch:      18458,
 			ProductivityThreshold:          85,
+			WakeBlockRewardStr:             "4800000000000000000",
 		},
 		Staking: Staking{
 			VoteWeightCalConsts: VoteWeightCalConsts{
@@ -448,6 +449,8 @@ type (
 		FoundationBonusP2EndEpoch uint64 `yaml:"foundationBonusP2EndEpoch"`
 		// ProductivityThreshold is the percentage number that a delegate's productivity needs to reach not to get probation
 		ProductivityThreshold uint64 `yaml:"productivityThreshold"`
+		// WakeBlockReward is the block reward amount starts from wake height in decimal string format
+		WakeBlockRewardStr string `yaml:"wakeBlockRewardStr"`
 	}
 	// Staking contains the configs for staking protocol
 	Staking struct {
@@ -836,7 +839,7 @@ func (r *Rewarding) EpochReward() *big.Int {
 func (r *Rewarding) AleutianEpochReward() *big.Int {
 	val, ok := new(big.Int).SetString(r.AleutianEpochRewardStr, 10)
 	if !ok {
-		log.S().Panicf("Error when casting epoch reward string %s into big int", r.EpochRewardStr)
+		log.S().Panicf("Error when casting epoch reward string %s into big int", r.AleutianEpochRewardStr)
 	}
 	return val
 }
@@ -845,7 +848,16 @@ func (r *Rewarding) AleutianEpochReward() *big.Int {
 func (r *Rewarding) DardanellesBlockReward() *big.Int {
 	val, ok := new(big.Int).SetString(r.DardanellesBlockRewardStr, 10)
 	if !ok {
-		log.S().Panicf("Error when casting block reward string %s into big int", r.EpochRewardStr)
+		log.S().Panicf("Error when casting block reward string %s into big int", r.DardanellesBlockRewardStr)
+	}
+	return val
+}
+
+// WakeBlockReward returns the block reward amount after wake fork
+func (r *Rewarding) WakeBlockReward() *big.Int {
+	val, ok := new(big.Int).SetString(r.WakeBlockRewardStr, 10)
+	if !ok {
+		log.S().Panicf("Error when casting block reward string %s into big int", r.WakeBlockRewardStr)
 	}
 	return val
 }

blockchain/genesis/genesis_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/iotexproject/iotex-address/address"
+	"github.com/iotexproject/iotex-core/v2/pkg/unit"
 )
 
 func TestDefaultConfig(t *testing.T) {
@@ -142,3 +143,14 @@ func TestDeployerWhitelist(t *testing.T) {
 		runTest(&g)
 	})
 }
+
+func TestWakeBlockReward(t *testing.T) {
+	r := require.New(t)
+	four, five := unit.ConvertIotxToRau(4), unit.ConvertIotxToRau(5)
+	four.Add(four, five)
+	four.Rsh(four, 1)
+	wake := Default.WakeBlockReward()
+	// wake block reward = 4.8, between 4.5 and 5
+	r.Equal(1, wake.Cmp(four))
+	r.Equal(-1, wake.Cmp(five))
+}

db/batch/batch.go

@@ -40,6 +40,8 @@ type (
 		ClearAndUnlock()
 		// Put insert or update a record identified by (namespace, key)
 		Put(string, []byte, []byte, string)
+		// Append appends a KVStoreBatch to the current batch
+		Append(KVStoreBatch)
 		// Delete deletes a record by (namespace, key)
 		Delete(string, []byte, string)
 		// Size returns the size of batch

db/batch/batch_impl.go

@@ -77,6 +77,27 @@ func (b *baseKVStoreBatch) Put(namespace string, key, value []byte, errorMessage
 	b.batch(Put, namespace, key, value, errorMessage)
 }
 
+func (b *baseKVStoreBatch) Append(kvb KVStoreBatch) {
+	b.mutex.Lock()
+	defer b.mutex.Unlock()
+	kvb.Lock()
+	defer kvb.Unlock()
+	for i := 0; i < kvb.Size(); i++ {
+		wi, err := b.Entry(i)
+		if err != nil {
+			panic(err)
+		}
+		switch wi.writeType {
+		case Put:
+			b.batch(Put, wi.namespace, wi.key, wi.value, wi.errorMessage)
+		case Delete:
+			b.batch(Delete, wi.namespace, wi.key, nil, wi.errorMessage)
+		default:
+			panic("unexpected write type")
+		}
+	}
+}
+
 // Delete deletes a record
 func (b *baseKVStoreBatch) Delete(namespace string, key []byte, errorMessage string) {
 	b.mutex.Lock()
@@ -280,16 +301,45 @@ func (cb *cachedBatch) touchKey(h kvCacheKey) {
 func (cb *cachedBatch) Put(namespace string, key, value []byte, errorMessage string) {
 	cb.lock.Lock()
 	defer cb.lock.Unlock()
+	cb.put(namespace, key, value, errorMessage)
+}
+
+func (cb *cachedBatch) put(namespace string, key, value []byte, errorMessage string) {
 	h := cb.hash(namespace, key)
 	cb.touchKey(h)
 	cb.currentCache().Write(&h, value)
 	cb.kvStoreBatch.batch(Put, namespace, key, value, errorMessage)
 }
 
+func (cb *cachedBatch) Append(b KVStoreBatch) {
+	cb.lock.Lock()
+	defer cb.lock.Unlock()
+	b.Lock()
+	defer b.Unlock()
+	for i := 0; i < b.Size(); i++ {
+		wi, err := b.Entry(i)
+		if err != nil {
+			panic(err)
+		}
+		switch wi.writeType {
+		case Put:
+			cb.put(wi.namespace, wi.key, wi.value, wi.errorMessage)
+		case Delete:
+			cb.delete(wi.namespace, wi.key, wi.errorMessage)
+		default:
+			panic("unexpected write type")
+		}
+	}
+}
+
 // Delete deletes a record
 func (cb *cachedBatch) Delete(namespace string, key []byte, errorMessage string) {
 	cb.lock.Lock()
 	defer cb.lock.Unlock()
+	cb.delete(namespace, key, errorMessage)
+}
+
+func (cb *cachedBatch) delete(namespace string, key []byte, errorMessage string) {
 	h := cb.hash(namespace, key)
 	cb.touchKey(h)
 	cb.currentCache().Evict(&h)

db/batch/batch_impl_test.go

@@ -71,6 +71,11 @@ func TestBaseKVStoreBatch(t *testing.T) {
 	require.NoError(err)
 	require.Equal("to_delete_ns", newEntry1.Namespace())
 	require.Equal(Put, newEntry1.WriteType())
+	bb := NewBatch()
+	bb.Put("bb", []byte("bbkey"), []byte("bbvalue"), "")
+	bb.Put("bb", []byte("bbkey2"), []byte("bbvalue2"), "")
+	b.Append(bb)
+	require.Equal(4, b.Size())
 	b.Clear()
 	require.Equal(0, b.Size())
 }
@@ -136,6 +141,11 @@ func TestCachedBatch(t *testing.T) {
 		}
 		return wi
 	}).SerializeQueue(nil, nil)))
+	bb := NewCachedBatch()
+	bb.Put("bb", []byte("bbkey"), []byte("bbvalue"), "")
+	bb.Put("bb", []byte("bbkey2"), []byte("bbvalue2"), "")
+	cb.Append(bb)
+	require.Equal(3, cb.Size())
 	cb.Clear()
 	require.Equal(0, cb.Size())
 }

db/kvstorewithbuffer.go

@@ -8,7 +8,6 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/iotexproject/iotex-core/v2/db/batch"
-	"github.com/iotexproject/iotex-core/v2/pkg/log"
 )
 
 type (
@@ -248,38 +247,6 @@ func (kvb *kvStoreWithBuffer) Filter(ns string, cond Condition, minKey, maxKey [
 }
 
 func (kvb *kvStoreWithBuffer) WriteBatch(b batch.KVStoreBatch) (err error) {
-	b.Lock()
-	defer func() {
-		if err == nil {
-			// clear the batch if commit succeeds
-			b.ClearAndUnlock()
-		} else {
-			b.Unlock()
-		}
-	}()
-	writes := make([]*batch.WriteInfo, b.Size())
-	for i := 0; i < b.Size(); i++ {
-		write, e := b.Entry(i)
-		if e != nil {
-			return e
-		}
-		if write.WriteType() != batch.Put && write.WriteType() != batch.Delete {
-			return errors.Errorf("invalid write type %d", write.WriteType())
-		}
-		writes[i] = write
-	}
-	kvb.buffer.Lock()
-	defer kvb.buffer.Unlock()
-	for _, write := range writes {
-		switch write.WriteType() {
-		case batch.Put:
-			kvb.buffer.Put(write.Namespace(), write.Key(), write.Value(), write.Error())
-		case batch.Delete:
-			kvb.buffer.Delete(write.Namespace(), write.Key(), write.Error())
-		default:
-			log.S().Panic("unexpected write type")
-		}
-	}
-
+	kvb.buffer.Append(b)
 	return nil
 }