diff --git a/api/api_public_klay.go b/api/api_public_klay.go index a0920111c..8cd1339fc 100644 --- a/api/api_public_klay.go +++ b/api/api_public_klay.go @@ -110,7 +110,7 @@ type TotalSupplyResult struct { TotalSupply *hexutil.Big `json:"totalSupply"` // The total supply of the native token. i.e. Minted - Burnt. TotalMinted *hexutil.Big `json:"totalMinted"` // Total minted amount. TotalBurnt *hexutil.Big `json:"totalBurnt"` // Total burnt amount. Sum of all burnt amounts below. - BurntFee *hexutil.Big `json:"burntFee"` // from tx fee burn. ReadAccReward(num).BurntFee. + BurntFee *hexutil.Big `json:"burntFee"` // from tx fee burn. ReadSupplyCheckpoint(num).BurntFee. ZeroBurn *hexutil.Big `json:"zeroBurn"` // balance of 0x0 (zero) address. DeadBurn *hexutil.Big `json:"deadBurn"` // balance of 0xdead (dead) address. Kip103Burn *hexutil.Big `json:"kip103Burn"` // by KIP103 fork. Read from its memo. diff --git a/blockchain/blockchain.go b/blockchain/blockchain.go index af70afb37..12a158497 100644 --- a/blockchain/blockchain.go +++ b/blockchain/blockchain.go @@ -613,8 +613,8 @@ func (bc *BlockChain) setHeadBeyondRoot(head uint64, root common.Hash, repair bo } // Rewind SupplyCheckpoints to highest checkpoint before new head - newLastAccRewardBlockNumber := header.Number.Uint64() - (header.Number.Uint64() % params.SupplyCheckpointInterval) - bc.db.WriteLastAccRewardBlockNumber(newLastAccRewardBlockNumber) + newLastSupplyCheckpointNumber := header.Number.Uint64() - (header.Number.Uint64() % params.SupplyCheckpointInterval) + bc.db.WriteLastSupplyCheckpointNumber(newLastSupplyCheckpointNumber) return bc.CurrentBlock().Number().Uint64(), nil } @@ -634,7 +634,7 @@ func (bc *BlockChain) setHeadBeyondRoot(head uint64, root common.Hash, repair bo if bc.Config().Istanbul.ProposerPolicy == params.WeightedRandom && !bc.Config().IsKaiaForkEnabled(new(big.Int).SetUint64(num)) && params.IsStakingUpdateInterval(num) { bc.db.DeleteStakingInfo(num) } - bc.db.DeleteAccReward(num) + bc.db.DeleteSupplyCheckpoint(num) } // If SetHead was only called as a chain reparation method, try to skip diff --git a/reward/supply_manager.go b/reward/supply_manager.go index 715395a20..7f29aa7a6 100644 --- a/reward/supply_manager.go +++ b/reward/supply_manager.go @@ -78,7 +78,7 @@ type TotalSupply struct { TotalSupply *big.Int // The total supply of the native token. i.e. Minted - Burnt. TotalMinted *big.Int // Total minted amount. TotalBurnt *big.Int // Total burnt amount. Sum of all burnt amounts below. - BurntFee *big.Int // from tx fee burn. ReadAccReward(num).BurntFee. + BurntFee *big.Int // from tx fee burn. ReadSupplyCheckpoint(num).BurntFee. ZeroBurn *big.Int // balance of 0x0 (zero) address. DeadBurn *big.Int // balance of 0xdead (dead) address. Kip103Burn *big.Int // by KIP103 fork. Read from its memo. @@ -134,9 +134,9 @@ func (sm *supplyManager) Stop() { } } -func (sm *supplyManager) GetAccReward(num uint64) (*database.AccReward, error) { +func (sm *supplyManager) GetAccReward(num uint64) (*database.SupplyCheckpoint, error) { if accReward, ok := sm.accRewardCache.Get(num); ok { - return accReward.(*database.AccReward), nil + return accReward.(*database.SupplyCheckpoint), nil } accReward, err := sm.getAccRewardUncached(num) @@ -279,12 +279,12 @@ func (sm *supplyManager) catchup() { var ( headNum = sm.chain.CurrentBlock().NumberU64() - lastNum = sm.db.ReadLastAccRewardBlockNumber() + lastNum = sm.db.ReadLastSupplyCheckpointNumber() ) - if lastNum > 0 && sm.db.ReadAccReward(lastNum) == nil { + if lastNum > 0 && sm.db.ReadSupplyCheckpoint(lastNum) == nil { logger.Error("Last accumulated reward not found. Restarting supply catchup", "last", lastNum, "head", headNum) - sm.db.WriteLastAccRewardBlockNumber(0) // soft reset to genesis + sm.db.WriteLastSupplyCheckpointNumber(0) // soft reset to genesis lastNum = 0 } @@ -296,17 +296,17 @@ func (sm *supplyManager) catchup() { logger.Error("totalSupplyFromState failed", "number", 0, "err", err) return } - sm.db.WriteAccReward(0, &database.AccReward{ + sm.db.WriteSupplyCheckpoint(0, &database.SupplyCheckpoint{ Minted: genesisTotalSupply, BurntFee: big.NewInt(0), }) - sm.db.WriteLastAccRewardBlockNumber(0) + sm.db.WriteLastSupplyCheckpointNumber(0) lastNum = 0 logger.Info("Stored genesis total supply", "supply", genesisTotalSupply) } - lastNum = sm.db.ReadLastAccRewardBlockNumber() - lastAccReward := sm.db.ReadAccReward(lastNum) + lastNum = sm.db.ReadLastSupplyCheckpointNumber() + lastAccReward := sm.db.ReadSupplyCheckpoint(lastNum) // Big-step catchup; accumulate until the head block as of now. // The head block can be obsolete by the time catchup finished, so the big-step can end up being a bit short. @@ -378,18 +378,18 @@ func (sm *supplyManager) totalSupplyFromState(num uint64) (*big.Int, error) { return totalSupply, nil } -func (sm *supplyManager) getAccRewardUncached(num uint64) (*database.AccReward, error) { - accReward := sm.db.ReadAccReward(num) +func (sm *supplyManager) getAccRewardUncached(num uint64) (*database.SupplyCheckpoint, error) { + accReward := sm.db.ReadSupplyCheckpoint(num) if accReward != nil { return accReward, nil } // Trace back to the last stored accumulated reward. var fromNum uint64 - var fromAcc *database.AccReward + var fromAcc *database.SupplyCheckpoint // Fast path using checkpointInterval - if accReward := sm.db.ReadAccReward(num - num%sm.checkpointInterval); accReward != nil { + if accReward := sm.db.ReadSupplyCheckpoint(num - num%sm.checkpointInterval); accReward != nil { logger.Trace("fast path reaccumulating rewards", "from", num-num%sm.checkpointInterval, "to", num) fromNum = num - num%sm.checkpointInterval fromAcc = accReward @@ -407,7 +407,7 @@ func (sm *supplyManager) getAccRewardUncached(num uint64) (*database.AccReward, // If `write` is true, the result will be written to the database. // If `write` is false, the result will not be written to the database, // to prevent overwriting LastAccRewardBlockNumber (essentially rollback) and to keep the disk size small (only store at checkpointInterval). -func (sm *supplyManager) accumulateReward(from, to uint64, fromAcc *database.AccReward, write bool) (*database.AccReward, error) { +func (sm *supplyManager) accumulateReward(from, to uint64, fromAcc *database.SupplyCheckpoint, write bool) (*database.SupplyCheckpoint, error) { accReward := fromAcc.Copy() // make a copy because we're updating it in-place. for num := from + 1; num <= to; num++ { @@ -437,8 +437,8 @@ func (sm *supplyManager) accumulateReward(from, to uint64, fromAcc *database.Acc // Store to database, print progress log. sm.accRewardCache.Add(num, accReward.Copy()) if write && (num%sm.checkpointInterval) == 0 { - sm.db.WriteAccReward(num, accReward) - sm.db.WriteLastAccRewardBlockNumber(num) + sm.db.WriteSupplyCheckpoint(num, accReward) + sm.db.WriteLastSupplyCheckpointNumber(num) } if (num % supplyLogInterval) == 0 { logger.Info("Accumulated block rewards", "number", num, "minted", accReward.Minted.String(), "burntFee", accReward.BurntFee.String()) diff --git a/reward/supply_manager_test.go b/reward/supply_manager_test.go index ec599c556..003dfa31d 100644 --- a/reward/supply_manager_test.go +++ b/reward/supply_manager_test.go @@ -249,9 +249,9 @@ func (s *SupplyTestSuite) TestBlockRewind() { } s.chain.SetHead(200) - assert.Equal(t, uint64(128), s.db.ReadLastAccRewardBlockNumber()) - assert.NotNil(t, s.db.ReadAccReward(128)) - assert.Nil(t, s.db.ReadAccReward(256)) + assert.Equal(t, uint64(128), s.db.ReadLastSupplyCheckpointNumber()) + assert.NotNil(t, s.db.ReadSupplyCheckpoint(128)) + assert.Nil(t, s.db.ReadSupplyCheckpoint(256)) s.insertBlocks(201) @@ -337,7 +337,7 @@ func (s *SupplyTestSuite) TestTotalSupplyPartialInfo() { assert.Equal(t, expected.Kip160Burn, ts.Kip160Burn) // No AccReward - s.db.DeleteAccReward(num - (num % 128)) + s.db.DeleteSupplyCheckpoint(num - (num % 128)) s.sm.accRewardCache.Purge() ts, err = s.sm.GetTotalSupply(num) assert.ErrorIs(t, err, errNoAccReward) diff --git a/storage/database/db_manager.go b/storage/database/db_manager.go index 3520f2d65..a76df9bbc 100644 --- a/storage/database/db_manager.go +++ b/storage/database/db_manager.go @@ -301,11 +301,11 @@ type DBManager interface { DeleteStakingInfo(blockNum uint64) // Accumulated block rewards functions - ReadAccReward(blockNum uint64) *AccReward - WriteAccReward(blockNum uint64, accReward *AccReward) - DeleteAccReward(blockNum uint64) - ReadLastAccRewardBlockNumber() uint64 - WriteLastAccRewardBlockNumber(blockNum uint64) + ReadSupplyCheckpoint(blockNum uint64) *SupplyCheckpoint + WriteSupplyCheckpoint(blockNum uint64, accReward *SupplyCheckpoint) + DeleteSupplyCheckpoint(blockNum uint64) + ReadLastSupplyCheckpointNumber() uint64 + WriteLastSupplyCheckpointNumber(blockNum uint64) // DB migration related function StartDBMigration(DBManager) error @@ -2876,11 +2876,11 @@ func (dbm *databaseManager) ReadGovernanceState() ([]byte, error) { return db.Get(governanceStateKey) } -// ReadAccReward retrieves the accumulated reward (minted, burntFee) up to a specific block number. +// ReadSupplyCheckpoint retrieves the accumulated reward (minted, burntFee) up to a specific block number. // Returns nil if the accumulated reward is not stored. -func (dbm *databaseManager) ReadAccReward(blockNum uint64) *AccReward { +func (dbm *databaseManager) ReadSupplyCheckpoint(blockNum uint64) *SupplyCheckpoint { db := dbm.getDatabase(MiscDB) - data, err := db.Get(accRewardKey(blockNum)) + data, err := db.Get(supplyCheckpointKey(blockNum)) if len(data) == 0 || err != nil { return nil } @@ -2891,14 +2891,14 @@ func (dbm *databaseManager) ReadAccReward(blockNum uint64) *AccReward { if err := rlp.DecodeBytes(data, &stored); err != nil { logger.Crit("Corrupt accumulated reward", "err", err) } - return &AccReward{ + return &SupplyCheckpoint{ Minted: new(big.Int).SetBytes(stored.Minted), BurntFee: new(big.Int).SetBytes(stored.BurntFee), } } -// WriteAccReward stores the accumulated reward (minted, burntFee) up to a specific block number. -func (dbm *databaseManager) WriteAccReward(blockNum uint64, accReward *AccReward) { +// WriteSupplyCheckpoint stores the accumulated reward (minted, burntFee) up to a specific block number. +func (dbm *databaseManager) WriteSupplyCheckpoint(blockNum uint64, accReward *SupplyCheckpoint) { db := dbm.getDatabase(MiscDB) stored := struct { Minted []byte @@ -2911,23 +2911,23 @@ func (dbm *databaseManager) WriteAccReward(blockNum uint64, accReward *AccReward if err != nil { logger.Crit("Failed to write accumulated reward", "err", err) } - if err := db.Put(accRewardKey(blockNum), data); err != nil { + if err := db.Put(supplyCheckpointKey(blockNum), data); err != nil { logger.Crit("Failed to write accumulated reward", "err", err) } } -// DeleteAccReward removes the accumulated reward at a specific block number. -func (dbm *databaseManager) DeleteAccReward(blockNum uint64) { +// DeleteSupplyCheckpoint removes the accumulated reward at a specific block number. +func (dbm *databaseManager) DeleteSupplyCheckpoint(blockNum uint64) { db := dbm.getDatabase(MiscDB) - if err := db.Delete(accRewardKey(blockNum)); err != nil { + if err := db.Delete(supplyCheckpointKey(blockNum)); err != nil { logger.Crit("Failed to delete accumulated reward", "err", err) } } -// ReadLastAccRewardBlockNumber retrieves the last block number for which the accumulated reward is stored. -func (dbm *databaseManager) ReadLastAccRewardBlockNumber() uint64 { +// ReadLastSupplyCheckpointNumber retrieves the last block number for which the accumulated reward is stored. +func (dbm *databaseManager) ReadLastSupplyCheckpointNumber() uint64 { db := dbm.getDatabase(MiscDB) - data, err := db.Get(lastAccRewardBlockNumberKey) + data, err := db.Get(lastCheckpointNumberKey) if len(data) == 0 || err != nil { return 0 } else { @@ -2935,11 +2935,11 @@ func (dbm *databaseManager) ReadLastAccRewardBlockNumber() uint64 { } } -// WriteLastAccRewardBlockNumber stores the last block number for which the accumulated reward is stored. -func (dbm *databaseManager) WriteLastAccRewardBlockNumber(blockNum uint64) { +// WriteLastSupplyCheckpointNumber stores the last block number for which the accumulated reward is stored. +func (dbm *databaseManager) WriteLastSupplyCheckpointNumber(blockNum uint64) { db := dbm.getDatabase(MiscDB) data := common.Int64ToByteBigEndian(blockNum) - if err := db.Put(lastAccRewardBlockNumberKey, data); err != nil { + if err := db.Put(lastCheckpointNumberKey, data); err != nil { logger.Crit("Failed to write last accumulated reward block number", "err", err) } } diff --git a/storage/database/db_manager_test.go b/storage/database/db_manager_test.go index 0059652ee..74e3c2d5d 100644 --- a/storage/database/db_manager_test.go +++ b/storage/database/db_manager_test.go @@ -827,24 +827,24 @@ func TestDBManager_AccReward(t *testing.T) { // AccReward testcases := []struct { Number uint64 - AccReward *AccReward + AccReward *SupplyCheckpoint }{ - {1000, &AccReward{big.NewInt(1111), big.NewInt(99)}}, - {2000, &AccReward{big.NewInt(0), big.NewInt(88)}}, - {3000, &AccReward{big.NewInt(2222), big.NewInt(0)}}, - {4000, &AccReward{big.NewInt(0), big.NewInt(0)}}, + {1000, &SupplyCheckpoint{big.NewInt(1111), big.NewInt(99)}}, + {2000, &SupplyCheckpoint{big.NewInt(0), big.NewInt(88)}}, + {3000, &SupplyCheckpoint{big.NewInt(2222), big.NewInt(0)}}, + {4000, &SupplyCheckpoint{big.NewInt(0), big.NewInt(0)}}, } for _, tc := range testcases { - assert.Nil(t, dbm.ReadAccReward(tc.Number)) - dbm.WriteAccReward(tc.Number, tc.AccReward) - assert.Equal(t, tc.AccReward, dbm.ReadAccReward(tc.Number)) + assert.Nil(t, dbm.ReadSupplyCheckpoint(tc.Number)) + dbm.WriteSupplyCheckpoint(tc.Number, tc.AccReward) + assert.Equal(t, tc.AccReward, dbm.ReadSupplyCheckpoint(tc.Number)) } // LastAccRewardBlockNumber lastNum := uint64(54321) - assert.Zero(t, dbm.ReadLastAccRewardBlockNumber()) - dbm.WriteLastAccRewardBlockNumber(lastNum) - assert.Equal(t, lastNum, dbm.ReadLastAccRewardBlockNumber()) + assert.Zero(t, dbm.ReadLastSupplyCheckpointNumber()) + dbm.WriteLastSupplyCheckpointNumber(lastNum) + assert.Equal(t, lastNum, dbm.ReadLastSupplyCheckpointNumber()) } } diff --git a/storage/database/schema.go b/storage/database/schema.go index dce7d3af9..65b46973b 100644 --- a/storage/database/schema.go +++ b/storage/database/schema.go @@ -132,8 +132,8 @@ var ( stakingInfoPrefix = []byte("stakingInfo") - accRewardPrefix = []byte("accReward") - lastAccRewardBlockNumberKey = []byte("lastAccRewardBlockNumber") + supplyCheckpointPrefix = []byte("supplyCheckpoint") + lastCheckpointNumberKey = []byte("lastSupplyCheckpointNumber") chaindatafetcherCheckpointKey = []byte("chaindatafetcherCheckpoint") ) @@ -300,19 +300,18 @@ func parsePruningMarkKey(key []byte) PruningMark { } } -type AccReward struct { +type SupplyCheckpoint struct { Minted *big.Int BurntFee *big.Int } -func (ar *AccReward) Copy() *AccReward { - return &AccReward{ +func (ar *SupplyCheckpoint) Copy() *SupplyCheckpoint { + return &SupplyCheckpoint{ Minted: new(big.Int).Set(ar.Minted), BurntFee: new(big.Int).Set(ar.BurntFee), } } -// AccRewardKey = accRewardPrefix + blockNumber -func accRewardKey(blockNumber uint64) []byte { - return append(accRewardPrefix, common.Int64ToByteBigEndian(blockNumber)...) +func supplyCheckpointKey(blockNumber uint64) []byte { + return append(supplyCheckpointPrefix, common.Int64ToByteBigEndian(blockNumber)...) }