nihilist/monero
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Adjust difficulty target (2 min) and full reward zone (60 kbytes) for block version 2

Browse Source
This commit is contained in:
Javier Smooth 2015-11-05 01:58:47 -08:00
parent ea7380aa7f
commit 4fea1a5fe7
8 changed files with 38 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/cryptonote_config.h
View File

@ -51,11 +51,12 @@
// MONEY_SUPPLY - total number coins to be generated // MONEY_SUPPLY - total number coins to be generated
#define MONEY_SUPPLY ((uint64_t)(-1)) #define MONEY_SUPPLY ((uint64_t)(-1))
#define EMISSION_SPEED_FACTOR (20) #define EMISSION_SPEED_FACTOR_PER_MINUTE (20)
#define FINAL_SUBSIDY_PER_MINUTE ((uint64_t)300000000000) // 3 * pow(10, 11) #define FINAL_SUBSIDY_PER_MINUTE ((uint64_t)300000000000) // 3 * pow(10, 11)
#define CRYPTONOTE_REWARD_BLOCKS_WINDOW 100 #define CRYPTONOTE_REWARD_BLOCKS_WINDOW 100
#define CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE 20000 //size of block (bytes) after which reward for block calculated using block size #define CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE 60000 //size of block (bytes) after which reward for block calculated using block size
#define CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 20000 //size of block (bytes) after which reward for block calculated using block size - before first fork
#define CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE 600 #define CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE 600
#define CRYPTONOTE_DISPLAY_DECIMAL_POINT 12 #define CRYPTONOTE_DISPLAY_DECIMAL_POINT 12
// COIN - number of smallest units in one coin // COIN - number of smallest units in one coin
@ -66,7 +67,8 @@
#define ORPHANED_BLOCKS_MAX_COUNT 100 #define ORPHANED_BLOCKS_MAX_COUNT 100
#define DIFFICULTY_TARGET 60 // seconds #define DIFFICULTY_TARGET 120 // seconds
#define DIFFICULTY_TARGET_V1 60 // seconds - before first fork
#define DIFFICULTY_WINDOW 720 // blocks #define DIFFICULTY_WINDOW 720 // blocks
#define DIFFICULTY_LAG 15 // !!! #define DIFFICULTY_LAG 15 // !!!
#define DIFFICULTY_CUT 60 // timestamps to cut after sorting #define DIFFICULTY_CUT 60 // timestamps to cut after sorting

13
src/cryptonote_core/blockchain.cpp
View File

@ -910,7 +910,7 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl
std::vector<size_t> last_blocks_sizes; std::vector<size_t> last_blocks_sizes;
get_last_n_blocks_sizes(last_blocks_sizes, CRYPTONOTE_REWARD_BLOCKS_WINDOW); get_last_n_blocks_sizes(last_blocks_sizes, CRYPTONOTE_REWARD_BLOCKS_WINDOW);
if (!get_block_reward(epee::misc_utils::median(last_blocks_sizes), cumulative_block_size, already_generated_coins, base_reward)) if (!get_block_reward(epee::misc_utils::median(last_blocks_sizes), cumulative_block_size, already_generated_coins, base_reward, get_current_hard_fork_version()))
{ {
LOG_PRINT_L1("block size " << cumulative_block_size << " is bigger than allowed for this blockchain"); LOG_PRINT_L1("block size " << cumulative_block_size << " is bigger than allowed for this blockchain");
return false; return false;
@ -2604,11 +2604,12 @@ bool Blockchain::handle_block_to_main_chain(const block& bl, const crypto::hash&
TIME_MEASURE_FINISH(addblock); TIME_MEASURE_FINISH(addblock);
update_next_cumulative_size_limit();
// this will not fail since check succeeded above // this will not fail since check succeeded above
m_hardfork->add(bl, new_height - 1); m_hardfork->add(bl, new_height - 1);
// do this after updating the hard fork state since the size limit may change due to fork
update_next_cumulative_size_limit();
LOG_PRINT_L1("+++++ BLOCK SUCCESSFULLY ADDED" << std::endl << "id:\t" << id << std::endl << "PoW:\t" << proof_of_work << std::endl << "HEIGHT " << new_height << ", difficulty:\t" << current_diffic << std::endl << "block reward: " << print_money(fee_summary + base_reward) << "(" << print_money(base_reward) << " + " << print_money(fee_summary) << "), coinbase_blob_size: " << coinbase_blob_size << ", cumulative size: " << cumulative_block_size << ", " << block_processing_time << "(" << target_calculating_time << "/" << longhash_calculating_time << ")ms"); LOG_PRINT_L1("+++++ BLOCK SUCCESSFULLY ADDED" << std::endl << "id:\t" << id << std::endl << "PoW:\t" << proof_of_work << std::endl << "HEIGHT " << new_height << ", difficulty:\t" << current_diffic << std::endl << "block reward: " << print_money(fee_summary + base_reward) << "(" << print_money(base_reward) << " + " << print_money(fee_summary) << "), coinbase_blob_size: " << coinbase_blob_size << ", cumulative size: " << cumulative_block_size << ", " << block_processing_time << "(" << target_calculating_time << "/" << longhash_calculating_time << ")ms");
if(m_show_time_stats) if(m_show_time_stats)
{ {
@ -2630,13 +2631,15 @@ bool Blockchain::handle_block_to_main_chain(const block& bl, const crypto::hash&
//------------------------------------------------------------------ //------------------------------------------------------------------
bool Blockchain::update_next_cumulative_size_limit() bool Blockchain::update_next_cumulative_size_limit()
{ {
uint64_t full_reward_zone = get_current_hard_fork_version() < 2 ? CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 : CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE;
LOG_PRINT_L3("Blockchain::" << __func__); LOG_PRINT_L3("Blockchain::" << __func__);
std::vector<size_t> sz; std::vector<size_t> sz;
get_last_n_blocks_sizes(sz, CRYPTONOTE_REWARD_BLOCKS_WINDOW); get_last_n_blocks_sizes(sz, CRYPTONOTE_REWARD_BLOCKS_WINDOW);
uint64_t median = epee::misc_utils::median(sz); uint64_t median = epee::misc_utils::median(sz);
if(median <= CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE) if(median <= full_reward_zone)
median = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE; median = full_reward_zone;
m_current_block_cumul_sz_limit = median*2; m_current_block_cumul_sz_limit = median*2;
return true; return true;

2
src/cryptonote_core/blockchain_storage.cpp
View File

@ -606,7 +606,7 @@ bool blockchain_storage::validate_miner_transaction(const block& b, size_t cumul
std::vector<size_t> last_blocks_sizes; std::vector<size_t> last_blocks_sizes;
get_last_n_blocks_sizes(last_blocks_sizes, CRYPTONOTE_REWARD_BLOCKS_WINDOW); get_last_n_blocks_sizes(last_blocks_sizes, CRYPTONOTE_REWARD_BLOCKS_WINDOW);
if (!get_block_reward(epee::misc_utils::median(last_blocks_sizes), cumulative_block_size, already_generated_coins, base_reward)) { if (!get_block_reward(epee::misc_utils::median(last_blocks_sizes), cumulative_block_size, already_generated_coins, base_reward,0)) {
LOG_PRINT_L1("block size " << cumulative_block_size << " is bigger than allowed for this blockchain"); LOG_PRINT_L1("block size " << cumulative_block_size << " is bigger than allowed for this blockchain");
return false; return false;
} }

19
src/cryptonote_core/cryptonote_basic_impl.cpp
View File

@ -73,16 +73,23 @@ namespace cryptonote {
return CRYPTONOTE_MAX_TX_SIZE; return CRYPTONOTE_MAX_TX_SIZE;
} }
//----------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------
bool get_block_reward(size_t median_size, size_t current_block_size, uint64_t already_generated_coins, uint64_t &reward) { bool get_block_reward(size_t median_size, size_t current_block_size, uint64_t already_generated_coins, uint64_t &reward, uint8_t version) {
uint64_t base_reward = (MONEY_SUPPLY - already_generated_coins) >> EMISSION_SPEED_FACTOR; static_assert(DIFFICULTY_TARGET%60==0&&DIFFICULTY_TARGET_V1%60==0,"difficulty targets must be a multiple of 60");
if (base_reward < FINAL_SUBSIDY_PER_MINUTE) const int target = version < 2 ? DIFFICULTY_TARGET_V1 : DIFFICULTY_TARGET;
const int target_minutes = target / 60;
const int emission_speed_factor = EMISSION_SPEED_FACTOR_PER_MINUTE - (target_minutes-1);
uint64_t base_reward = (MONEY_SUPPLY - already_generated_coins) >> emission_speed_factor;
if (base_reward < FINAL_SUBSIDY_PER_MINUTE*target_minutes)
{ {
base_reward = FINAL_SUBSIDY_PER_MINUTE; base_reward = FINAL_SUBSIDY_PER_MINUTE*target_minutes;
} }
uint64_t full_reward_zone = version < 2 ? CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 : CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE;
//make it soft //make it soft
if (median_size < CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE) { if (median_size < full_reward_zone) {
median_size = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE; median_size = full_reward_zone;
} }
if (current_block_size <= median_size) { if (current_block_size <= median_size) {

2
src/cryptonote_core/cryptonote_basic_impl.h
View File

@ -71,7 +71,7 @@ namespace cryptonote {
/************************************************************************/ /************************************************************************/
size_t get_max_block_size(); size_t get_max_block_size();
size_t get_max_tx_size(); size_t get_max_tx_size();
bool get_block_reward(size_t median_size, size_t current_block_size, uint64_t already_generated_coins, uint64_t &reward); bool get_block_reward(size_t median_size, size_t current_block_size, uint64_t already_generated_coins, uint64_t &reward, uint8_t version);
uint8_t get_account_address_checksum(const public_address_outer_blob& bl); uint8_t get_account_address_checksum(const public_address_outer_blob& bl);
uint8_t get_account_integrated_address_checksum(const public_integrated_address_outer_blob& bl); uint8_t get_account_integrated_address_checksum(const public_integrated_address_outer_blob& bl);

2
src/cryptonote_core/cryptonote_format_utils.cpp
View File

@ -120,7 +120,7 @@ namespace cryptonote
in.height = height; in.height = height;
uint64_t block_reward; uint64_t block_reward;
if(!get_block_reward(median_size, current_block_size, already_generated_coins, block_reward)) if(!get_block_reward(median_size, current_block_size, already_generated_coins, block_reward, hard_fork_version))
{ {
LOG_PRINT_L0("Block is too big"); LOG_PRINT_L0("Block is too big");
return false; return false;

4
tests/core_tests/chaingen.cpp
View File

@ -98,7 +98,7 @@ void test_generator::add_block(const cryptonote::block& blk, size_t tsx_size, st
{ {
const size_t block_size = tsx_size + get_object_blobsize(blk.miner_tx); const size_t block_size = tsx_size + get_object_blobsize(blk.miner_tx);
uint64_t block_reward; uint64_t block_reward;
get_block_reward(misc_utils::median(block_sizes), block_size, already_generated_coins, block_reward); get_block_reward(misc_utils::median(block_sizes), block_size, already_generated_coins, block_reward, 1);
m_blocks_info[get_block_hash(blk)] = block_info(blk.prev_id, already_generated_coins + block_reward, block_size); m_blocks_info[get_block_hash(blk)] = block_info(blk.prev_id, already_generated_coins + block_reward, block_size);
} }
@ -526,7 +526,7 @@ bool construct_miner_tx_manually(size_t height, uint64_t already_generated_coins
// This will work, until size of constructed block is less then CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE // This will work, until size of constructed block is less then CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE
uint64_t block_reward; uint64_t block_reward;
if (!get_block_reward(0, 0, already_generated_coins, block_reward)) if (!get_block_reward(0, 0, already_generated_coins, block_reward, 1))
{ {
LOG_PRINT_L0("Block is too big"); LOG_PRINT_L0("Block is too big");
return false; return false;

10
tests/unit_tests/block_reward.cpp
View File

@ -47,7 +47,7 @@ namespace
}; };
#define TEST_ALREADY_GENERATED_COINS(already_generated_coins, expected_reward) \ #define TEST_ALREADY_GENERATED_COINS(already_generated_coins, expected_reward) \
m_block_not_too_big = get_block_reward(0, current_block_size, already_generated_coins, m_block_reward); \ m_block_not_too_big = get_block_reward(0, current_block_size, already_generated_coins, m_block_reward,1); \
ASSERT_TRUE(m_block_not_too_big); \ ASSERT_TRUE(m_block_not_too_big); \
ASSERT_EQ(m_block_reward, expected_reward); ASSERT_EQ(m_block_reward, expected_reward);
@ -79,14 +79,14 @@ namespace
protected: protected:
virtual void SetUp() virtual void SetUp()
{ {
m_block_not_too_big = get_block_reward(0, 0, already_generated_coins, m_standard_block_reward); m_block_not_too_big = get_block_reward(0, 0, already_generated_coins, m_standard_block_reward, 1);
ASSERT_TRUE(m_block_not_too_big); ASSERT_TRUE(m_block_not_too_big);
ASSERT_LT(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE, m_standard_block_reward); ASSERT_LT(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE, m_standard_block_reward);
} }
void do_test(size_t median_block_size, size_t current_block_size) void do_test(size_t median_block_size, size_t current_block_size)
{ {
m_block_not_too_big = get_block_reward(median_block_size, current_block_size, already_generated_coins, m_block_reward); m_block_not_too_big = get_block_reward(median_block_size, current_block_size, already_generated_coins, m_block_reward, 1);
} }
static const uint64_t already_generated_coins = 0; static const uint64_t already_generated_coins = 0;
@ -168,14 +168,14 @@ namespace
m_last_block_sizes_median = 7 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE; m_last_block_sizes_median = 7 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE;
m_block_not_too_big = get_block_reward(epee::misc_utils::median(m_last_block_sizes), 0, already_generated_coins, m_standard_block_reward); m_block_not_too_big = get_block_reward(epee::misc_utils::median(m_last_block_sizes), 0, already_generated_coins, m_standard_block_reward, 1);
ASSERT_TRUE(m_block_not_too_big); ASSERT_TRUE(m_block_not_too_big);
ASSERT_LT(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE, m_standard_block_reward); ASSERT_LT(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE, m_standard_block_reward);
} }
void do_test(size_t current_block_size) void do_test(size_t current_block_size)
{ {
m_block_not_too_big = get_block_reward(epee::misc_utils::median(m_last_block_sizes), current_block_size, already_generated_coins, m_block_reward); m_block_not_too_big = get_block_reward(epee::misc_utils::median(m_last_block_sizes), current_block_size, already_generated_coins, m_block_reward, 1);
} }
static const uint64_t already_generated_coins = 0; static const uint64_t already_generated_coins = 0;