github.com/platonnetwork/platon-go@v0.7.6/cases/tests/ppos/Incentive_for_additional_issuance.py (about) 1 import math 2 import time 3 4 import pytest 5 from dacite import from_dict 6 from common.log import log 7 from client_sdk_python import Web3 8 from decimal import Decimal 9 from tests.conftest import get_client_consensus 10 from tests.lib import EconomicConfig, Genesis, assert_code, von_amount, Client 11 12 13 @pytest.mark.P1 14 def test_AL_FI_001_to_003(new_genesis_env, staking_cfg): 15 """ 16 AL_FI_001:查看每年释放补贴激励池变化 17 AL_FI_002:查看每年固定增发变化 18 AL_FI_003:第十年固定增发token分配 19 :param new_genesis_env: 20 :return: 21 """ 22 # Initialization genesis file Initial amount 23 node_count = len(new_genesis_env.consensus_node_list) 24 default_pledge_amount = Web3.toWei(node_count * 1500000, 'ether') 25 community_amount = default_pledge_amount + 259096239000000000000000000 + 62215742000000000000000000 26 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 27 genesis.economicModel.innerAcc.cdfBalance = community_amount 28 surplus_amount = str(EconomicConfig.TOKEN_TOTAL - community_amount - 200000000000000000000000000) 29 genesis.alloc = { 30 "1000000000000000000000000000000000000003": { 31 "balance": "200000000000000000000000000" 32 }, 33 "0x2e95E3ce0a54951eB9A99152A6d5827872dFB4FD": { 34 "balance": surplus_amount 35 } 36 } 37 new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" 38 genesis.to_file(new_file) 39 new_genesis_env.deploy_all(new_file) 40 41 client = get_client_consensus(new_genesis_env, staking_cfg) 42 economic = client.economic 43 node = client.node 44 # Query the initial amount of incentive pool 45 current_incentive_pool = 262215742000000000000000000 46 # Query the initial amount of a warehouse lock plan 47 init_foundationlockup = 259096239000000000000000000 48 # Issued token amount 49 init_token = 10000000000000000000000000000 50 # Query developer foundation initial amount 51 developer_foundation = 0 52 # Query the initial amount of the foundation 53 foundation_balance = 0 54 # Additional amount 55 total_amount_of_issuance = 0 56 remaining_settlement_cycle = 0 57 end_cycle_timestamp = None 58 # Annual issuance 59 for i in range(10): 60 if i == 0: 61 incentive_pool = current_incentive_pool 62 log.info("Amount of initial incentive pool： {}".format(incentive_pool)) 63 foundation_lock_up = init_foundationlockup 64 log.info("Initial Lockup Plan Amount： {}".format(foundation_lock_up)) 65 total_amount_of_issuance = int(init_token + Decimal(str(init_token)) / Decimal(str(40))) 66 log.info("Current year Total amount of issuance： {}".format(total_amount_of_issuance)) 67 # Query the current annual incentive pool amount 68 current_annual_incentive_pool_amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, 0) 69 # Query current annual developer foundation amount 70 DEVELOPER_FOUNDATAION_ADDRESS = node.web3.toChecksumAddress(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS) 71 current_annual_developer_foundation_amount = node.eth.getBalance(DEVELOPER_FOUNDATAION_ADDRESS, 0) 72 # Query current annual fund amount 73 FOUNDATION_ADDRESS = node.web3.toChecksumAddress(EconomicConfig.FOUNDATION_ADDRESS) 74 current_annual_foundation_amount = node.eth.getBalance(FOUNDATION_ADDRESS, 0) 75 log.info( 76 "{} Year Incentive Pool Address: {} Balance: {}".format(i + 1, EconomicConfig.INCENTIVEPOOL_ADDRESS, 77 incentive_pool)) 78 log.info('{} Year Foundation Address: {} Balance: {}'.format(i + 1, EconomicConfig.FOUNDATION_ADDRESS, 79 foundation_balance)) 80 log.info("{} Year Developer Foundation Address:{} Balance:{}".format(i + 1, 81 EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS, 82 developer_foundation)) 83 log.info("{} Year Foundation Locking Address: {} Balance: {}".format(i + 1, 84 EconomicConfig.FOUNDATION_LOCKUP_ADDRESS, 85 foundation_lock_up)) 86 assert current_annual_incentive_pool_amount == incentive_pool, "{} Year Incentive Pool Address: {} Balance: {}".format( 87 i + 1, EconomicConfig.INCENTIVEPOOL_ADDRESS, incentive_pool) 88 assert current_annual_developer_foundation_amount == developer_foundation, "{} Year Developer Foundation Address:{} Balance:{}".format( 89 i + 1, 90 EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS, 91 developer_foundation) 92 assert current_annual_foundation_amount == foundation_balance, "{} Year Developer Foundation Address:{} Balance:{}".format( 93 i + 1, 94 EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS, 95 developer_foundation) 96 # log.info("{} Year additional Balance:{}".format(i + 1, total_amount_of_issuance)) 97 time.sleep(5) 98 economic.wait_settlement_blocknum(node) 99 while remaining_settlement_cycle != 1: 100 tmp_current_block = node.eth.blockNumber 101 if tmp_current_block % economic.settlement_size == 0: 102 time.sleep(1) 103 block_info = node.eth.getBlock(1) 104 log.info("block_info：{}".format(block_info)) 105 first_timestamp = block_info['timestamp'] 106 log.info("First block timestamp： {}".format(first_timestamp)) 107 end_cycle_timestamp = first_timestamp + (economic.additional_cycle_time * 60000) 108 log.info("End time stamp of current issue cycle： {}".format(end_cycle_timestamp)) 109 110 last_settlement_block = (math.ceil(tmp_current_block / economic.settlement_size) - 1) * economic.settlement_size 111 log.info("The last block height of the previous settlement period： {}".format(last_settlement_block)) 112 settlement_block_info = node.eth.getBlock(last_settlement_block) 113 settlement_timestamp = settlement_block_info['timestamp'] 114 log.info("High block timestamp at the end settlement cycle： {}".format(settlement_timestamp)) 115 remaining_additional_time = end_cycle_timestamp - settlement_timestamp 116 log.info("Remaining time of current issuance cycle： {}".format(remaining_additional_time)) 117 average_interval = (settlement_timestamp - first_timestamp) // (last_settlement_block - 1) 118 log.info("Block interval in the last settlement cycle： {}".format(average_interval)) 119 number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) 120 log.info("Remaining block height of current issuance cycle： {}".format(number_of_remaining_blocks)) 121 remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) 122 log.info( 123 "remaining settlement cycles in the current issuance cycle： {}".format(remaining_settlement_cycle)) 124 economic.wait_settlement_blocknum(node) 125 126 elif 0 < i < 9: 127 annual_last_block = (math.ceil(node.eth.blockNumber / economic.settlement_size) - 1) * economic.settlement_size 128 log.info("The last block height in the last issue cycle: {}".format(annual_last_block)) 129 # Current annual total issuance 130 additional_amount = int(Decimal(str(total_amount_of_issuance)) / Decimal(str(40))) 131 log.info("Current annual quota： {}".format(additional_amount)) 132 # Incentive pool additional amount 133 incentive_pool_additional_amount = int(Decimal(str(additional_amount)) * Decimal(str((80 / 100)))) 134 log.info("Additional quota for the current annual incentive pool: {}".format(incentive_pool_additional_amount)) 135 # developer foundation s additional amount 136 developer_foundation_s_additional_amount = additional_amount - incentive_pool_additional_amount 137 log.info("Current annual developer foundation additional quota: {}".format(developer_foundation_s_additional_amount)) 138 # Total amount of additional issuance 139 total_amount_of_issuance = total_amount_of_issuance + additional_amount 140 log.info("Total current hairstyle：{}".format(total_amount_of_issuance)) 141 # Current annual incentive pool amount 142 current_incentive_pool = current_incentive_pool + incentive_pool_additional_amount + EconomicConfig.release_info[i - 1]['amount'] 143 log.info("Balance to be allocated for the current annual incentive pool：{}".format(current_incentive_pool)) 144 # Current annual Developer Fund Amount 145 developer_foundation = developer_foundation + developer_foundation_s_additional_amount 146 log.info("Current Annual Developer Foundation Total： {}".format(developer_foundation)) 147 # Query the current annual incentive pool amount 148 current_annual_incentive_pool_amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, annual_last_block) 149 # Query current annual developer foundation amount 150 DEVELOPER_FOUNDATAION_ADDRESS = node.web3.toChecksumAddress(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS) 151 current_annual_developer_foundation_amount = node.eth.getBalance(DEVELOPER_FOUNDATAION_ADDRESS, annual_last_block) 152 # Query current annual fund amount 153 FOUNDATION_ADDRESS = node.web3.toChecksumAddress(EconomicConfig.FOUNDATION_ADDRESS) 154 current_annual_foundation_amount = node.eth.getBalance(FOUNDATION_ADDRESS, annual_last_block) 155 log.info("{} year initialization incentive pool address: {} balance: {}".format(i + 1, 156 EconomicConfig.INCENTIVEPOOL_ADDRESS, 157 current_incentive_pool)) 158 log.info('{} Year Initialization Foundation Address: {} balance: {}'.format(i + 1, 159 EconomicConfig.FOUNDATION_ADDRESS, 160 foundation_balance)) 161 log.info("{} Year Developer Fund Address: {} balance: {}".format(i + 1, 162 EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS, 163 developer_foundation)) 164 log.info("{} Year additional balance:{}".format(i + 1, additional_amount)) 165 assert current_annual_incentive_pool_amount == current_incentive_pool, "{} year initialization incentive pool address: {} balance: {}".format( 166 i + 1, EconomicConfig.INCENTIVEPOOL_ADDRESS, current_incentive_pool) 167 assert current_annual_developer_foundation_amount == developer_foundation, "{} Year Developer Fund Address: {} balance: {}".format( 168 i + 1, EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS, developer_foundation) 169 assert current_annual_foundation_amount == 0, '{} Year Initialization Foundation Address: {} balance: {}'.format( 170 i + 1, EconomicConfig.FOUNDATION_ADDRESS, foundation_balance) 171 # Waiting for the end of the annual issuance cycle 172 end_cycle_timestamp = end_cycle_timestamp + (economic.additional_cycle_time * 60000) 173 log.info("End time stamp of current issue cycle： {}".format(end_cycle_timestamp)) 174 settlement_block_info = node.eth.getBlock(annual_last_block) 175 settlement_timestamp = settlement_block_info['timestamp'] 176 log.info("High block timestamp at the end of settlement cycle： {}".format(settlement_timestamp)) 177 remaining_additional_time = end_cycle_timestamp - settlement_timestamp 178 log.info("Remaining time of current issuance cycle： {}".format(remaining_additional_time)) 179 result = client.ppos.getAvgPackTime() 180 average_interval = result['Ret'] 181 log.info("Block interval on the chain：{}".format(average_interval)) 182 log.info("Block interval on the chain：{}".format(average_interval)) 183 number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) 184 log.info("Remaining block height of current issuance cycle： {}".format(number_of_remaining_blocks)) 185 remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) 186 log.info("remaining settlement cycles issuance cycle： {}".format(remaining_settlement_cycle)) 187 while remaining_settlement_cycle != 1: 188 tmp_current_block = node.eth.blockNumber 189 if tmp_current_block % economic.settlement_size == 0: 190 time.sleep(economic.interval) 191 tmp_current_block = node.eth.blockNumber 192 last_settlement_block = (math.ceil( 193 tmp_current_block / economic.settlement_size) - 1) * economic.settlement_size 194 log.info("The last block height of the previous settlement period： {}".format(last_settlement_block)) 195 settlement_block_info = node.eth.getBlock(last_settlement_block) 196 settlement_timestamp = settlement_block_info['timestamp'] 197 log.info("High block timestamp at the end of settlement cycle： {}".format(settlement_timestamp)) 198 remaining_additional_time = end_cycle_timestamp - settlement_timestamp 199 log.info("Remaining time of current issuance cycle： {}".format(remaining_additional_time)) 200 result = client.ppos.getAvgPackTime() 201 average_interval = result['Ret'] 202 log.info("Block interval on the chain：{}".format(average_interval)) 203 number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) 204 log.info("Remaining block height of current issuance cycle： {}".format(number_of_remaining_blocks)) 205 remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) 206 log.info("remaining settlement cycles issuance cycle： {}".format(remaining_settlement_cycle)) 207 economic.wait_settlement_blocknum(node) 208 else: 209 annual_last_block = (math.ceil(node.eth.blockNumber / economic.settlement_size) - 1) * economic.settlement_size 210 # Current annual total issuance 211 additional_amount = int(Decimal(str(total_amount_of_issuance)) / Decimal(str(40))) 212 # Incentive pool additional amount 213 incentive_pool_additional_amount = int(Decimal(str(additional_amount)) * Decimal(str((80 / 100)))) 214 # developer foundation s additional amount 215 developer_foundation_s_additional_amount = int( 216 Decimal(str(additional_amount - incentive_pool_additional_amount)) * Decimal(str((50 / 100)))) 217 # Foundation grant additional amount 218 foundation_grant_amount = additional_amount - incentive_pool_additional_amount - developer_foundation_s_additional_amount 219 # Total amount of additional issuance 220 total_amount_of_issuance = total_amount_of_issuance + additional_amount 221 # Current annual incentive pool amount 222 current_incentive_pool = current_incentive_pool + incentive_pool_additional_amount 223 # Current annual Developer Fund Amount 224 developer_foundation = developer_foundation + developer_foundation_s_additional_amount 225 # Current annual fund amount 226 foundation_balance = foundation_balance + foundation_grant_amount 227 # Query the current annual incentive pool amount 228 current_annual_incentive_pool_amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, annual_last_block) 229 # Query current annual developer foundation amount 230 DEVELOPER_FOUNDATAION_ADDRESS = node.web3.toChecksumAddress(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS) 231 current_annual_developer_foundation_amount = node.eth.getBalance(DEVELOPER_FOUNDATAION_ADDRESS, annual_last_block) 232 # Query current annual fund amount 233 FOUNDATION_ADDRESS = node.web3.toChecksumAddress(EconomicConfig.FOUNDATION_ADDRESS) 234 current_annual_foundation_amount = node.eth.getBalance(FOUNDATION_ADDRESS, annual_last_block) 235 log.info("{} year initialization incentive pool address: {} balance: {}".format(i + 1, 236 EconomicConfig.INCENTIVEPOOL_ADDRESS, 237 current_incentive_pool)) 238 log.info('{} Year Initialization Foundation Address: {} balance: {}'.format(i + 1, 239 EconomicConfig.FOUNDATION_ADDRESS, 240 foundation_balance)) 241 log.info("{} Year Developer Fund Address: {} balance: {}".format(i + 1, 242 EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS, 243 developer_foundation)) 244 log.info("{} Year additional balance:{}".format(i + 1, additional_amount)) 245 assert current_annual_incentive_pool_amount == current_incentive_pool, "{} year initialization incentive pool address: {} balance: {}".format( 246 i + 1, EconomicConfig.INCENTIVEPOOL_ADDRESS, current_incentive_pool) 247 assert current_annual_developer_foundation_amount == developer_foundation, "{} Year Developer Fund Address: {} balance: {}".format( 248 i + 1, EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS, developer_foundation) 249 assert current_annual_foundation_amount == foundation_balance, '{} Year Initialization Foundation Address: {} balance: {}'.format( 250 i + 1, EconomicConfig.FOUNDATION_ADDRESS, foundation_balance) 251 252 253 @pytest.mark.p1 254 def test_AL_FI_004_005(new_genesis_env, staking_cfg): 255 """ 256 AL_FI_004:查看每年区块奖励变化 257 AL_FI_005:查看每年质押奖励变化 258 :param new_genesis_env: 259 :param staking_cfg: 260 :return: 261 """ 262 # Initialization genesis file Initial amount 263 node_count = len(new_genesis_env.consensus_node_list) 264 default_pledge_amount = Web3.toWei(node_count * 1500000, 'ether') 265 community_amount = default_pledge_amount + 259096239000000000000000000 + 62215742000000000000000000 266 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 267 genesis.economicModel.innerAcc.cdfBalance = community_amount 268 surplus_amount = str(EconomicConfig.TOKEN_TOTAL - community_amount - 200000000000000000000000000) 269 genesis.alloc = { 270 "1000000000000000000000000000000000000003": { 271 "balance": "200000000000000000000000000" 272 }, 273 "0x2e95E3ce0a54951eB9A99152A6d5827872dFB4FD": { 274 "balance": surplus_amount 275 } 276 } 277 new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" 278 genesis.to_file(new_file) 279 new_genesis_env.deploy_all(new_file) 280 normal_node = new_genesis_env.get_a_normal_node() 281 client = Client(new_genesis_env, normal_node, staking_cfg) 282 economic = client.economic 283 node = client.node 284 log.info("Current connection node：{}".format(node.node_mark)) 285 log.info("Current connection nodeid：{}".format(node.node_id)) 286 address, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) 287 log.info("address: {}".format(address)) 288 address1, _ = economic.account.generate_account(node.web3, 0) 289 log.info("address1: {}".format(address1)) 290 end_cycle_timestamp = None 291 for i in range(10): 292 result = client.staking.create_staking(0, address1, address) 293 assert_code(result, 0) 294 # view account amount 295 benifit_balance = node.eth.getBalance(address1) 296 log.info("benifit_balance: {}".format(benifit_balance)) 297 # Wait for the settlement round to end 298 economic.wait_settlement_blocknum(node) 299 # 获取当前结算周期验证人 300 verifier_list = node.ppos.getVerifierList() 301 log.info("verifier_list: {}".format(verifier_list)) 302 # view block_reward 303 block_reward, staking_reward = economic.get_current_year_reward(node) 304 log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 305 # withdrew of pledge 306 result = client.staking.withdrew_staking(address) 307 assert_code(result, 0) 308 # wait settlement block 309 economic.wait_settlement_blocknum(node) 310 # wait consensus block 311 economic.wait_consensus_blocknum(node) 312 # count the number of blocks 313 blocknumber = economic.get_block_count_number(node, 10) 314 log.info("blocknumber: {}".format(blocknumber)) 315 # view account amount again 316 benifit_balance1 = node.eth.getBalance(address1) 317 log.info("benifit_balance: {}".format(benifit_balance1)) 318 reward = int(blocknumber * Decimal(str(block_reward))) 319 assert benifit_balance1 == benifit_balance + staking_reward + reward, "ErrMsg:benifit_balance: {}".format( 320 benifit_balance1) 321 if i == 0: 322 block_info = node.eth.getBlock(1) 323 log.info("block_info：{}".format(block_info)) 324 first_timestamp = block_info['timestamp'] 325 log.info("First block timestamp： {}".format(first_timestamp)) 326 end_cycle_timestamp = first_timestamp + (economic.additional_cycle_time * 60000) 327 log.info("End time stamp of current issue cycle： {}".format(end_cycle_timestamp)) 328 else: 329 # Waiting for the end of the annual issuance cycle 330 end_cycle_timestamp = end_cycle_timestamp + (economic.additional_cycle_time * 60000) 331 log.info("End time stamp of current issue cycle： {}".format(end_cycle_timestamp)) 332 annual_last_block = (math.ceil(node.eth.blockNumber / economic.settlement_size) - 1) * economic.settlement_size 333 log.info("The last block height in the last issue cycle: {}".format(annual_last_block)) 334 settlement_block_info = node.eth.getBlock(annual_last_block) 335 settlement_timestamp = settlement_block_info['timestamp'] 336 log.info("High block timestamp at the end of settlement cycle： {}".format(settlement_timestamp)) 337 remaining_additional_time = end_cycle_timestamp - settlement_timestamp 338 log.info("Remaining time of current issuance cycle： {}".format(remaining_additional_time)) 339 result = client.ppos.getAvgPackTime() 340 average_interval = result['Ret'] 341 log.info("Block interval on the chain：{}".format(average_interval)) 342 log.info("Block interval on the chain：{}".format(average_interval)) 343 number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) 344 log.info("Remaining block height of current issuance cycle： {}".format(number_of_remaining_blocks)) 345 remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) 346 log.info("remaining settlement cycles issuance cycle： {}".format(remaining_settlement_cycle)) 347 while remaining_settlement_cycle != 1: 348 tmp_current_block = node.eth.blockNumber 349 if tmp_current_block % economic.settlement_size == 0: 350 time.sleep(economic.interval) 351 tmp_current_block = node.eth.blockNumber 352 last_settlement_block = (math.ceil( 353 tmp_current_block / economic.settlement_size) - 1) * economic.settlement_size 354 log.info("The last block height of the previous settlement period： {}".format(last_settlement_block)) 355 settlement_block_info = node.eth.getBlock(last_settlement_block) 356 settlement_timestamp = settlement_block_info['timestamp'] 357 log.info("High block timestamp at the end of settlement cycle： {}".format(settlement_timestamp)) 358 remaining_additional_time = end_cycle_timestamp - settlement_timestamp 359 log.info("Remaining time of current issuance cycle： {}".format(remaining_additional_time)) 360 result = client.ppos.getAvgPackTime() 361 average_interval = result['Ret'] 362 log.info("Block interval on the chain：{}".format(average_interval)) 363 number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) 364 log.info("Remaining block height of current issuance cycle： {}".format(number_of_remaining_blocks)) 365 remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) 366 log.info("remaining settlement cycles issuance cycle： {}".format(remaining_settlement_cycle)) 367 economic.wait_settlement_blocknum(node) 368