github.com/platonnetwork/platon-go@v0.7.6/cases/tests/ppos_2/test_withdrewDelegate.py (about) 1 # -*- coding: utf-8 -*- 2 from tests.lib.utils import * 3 import pytest 4 from tests.lib.config import EconomicConfig 5 6 7 @pytest.mark.P0 8 @pytest.mark.compatibility 9 def test_ROE_001_007_015(client_new_node): 10 """ 11 :param client_new_node_obj: 12 :param get_generate_account: 13 :return: 14 """ 15 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 16 10 ** 18 * 10000000) 17 client_new_node.staking.create_staking(0, address, address) 18 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 19 10 ** 18 * 10000000) 20 result = client_new_node.delegate.delegate(0, address1) 21 log.info(result) 22 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 23 staking_blocknum = msg["Ret"]["StakingBlockNum"] 24 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1) 25 assert_code(result, 0) 26 27 28 @pytest.mark.P1 29 def test_ROE_002(client_new_node): 30 """ 31 :param client_new_node_obj: 32 :param get_generate_account: 33 :return: 34 """ 35 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 36 10 ** 18 * 10000000) 37 client_new_node.staking.create_staking(0, address, address) 38 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 39 10 ** 18 * 10000000) 40 result = client_new_node.delegate.delegate(0, address1) 41 log.info(result) 42 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 43 staking_blocknum = msg["Ret"]["StakingBlockNum"] 44 cfg = {"gas": 1} 45 status = 0 46 try: 47 client_new_node.delegate.withdrew_delegate(staking_blocknum, address1, transaction_cfg=cfg) 48 except BaseException: 49 status = 1 50 assert status == 1 51 52 53 @pytest.mark.P3 54 def test_ROE_003(client_new_node): 55 """ 56 :param client_new_node_obj: 57 :param get_generate_account: 58 :return: 59 """ 60 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 61 10 ** 18 * 10000000) 62 client_new_node.staking.create_staking(0, address, address) 63 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 64 10 ** 18 * 10000000) 65 result = client_new_node.delegate.delegate(0, address1) 66 log.info(result) 67 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 68 staking_blocknum = msg["Ret"]["StakingBlockNum"] 69 illegal_nodeID = "7ee3276fd6b9c7864eb896310b5393324b6db785a2528c00cc28ca8c" \ 70 "3f86fc229a86f138b1f1c8e3a942204c03faeb40e3b22ab11b8983c35dc025de42865990" 71 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1, node_id=illegal_nodeID) 72 log.info(result) 73 assert_code(result, 301109) 74 75 76 @pytest.mark.P1 77 def test_ROE_004(client_new_node): 78 """ 79 :param client_new_node_obj: 80 :return: 81 """ 82 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 83 10 ** 18 * 10000000) 84 client_new_node.staking.create_staking(0, address, address) 85 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 86 10 ** 18 * 10000000) 87 result = client_new_node.delegate.delegate(0, address1) 88 log.info(result) 89 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 90 staking_blocknum = msg["Ret"]["StakingBlockNum"] 91 92 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1, 93 amount=client_new_node.economic.delegate_limit + 1) 94 assert_code(result, 301113) 95 96 97 @pytest.mark.P1 98 def test_ROE_005_018(client_new_node): 99 """ 100 :param client_new_node_obj: 101 :return: 102 """ 103 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 104 10 ** 18 * 10000000) 105 client_new_node.staking.create_staking(0, address, address) 106 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 107 10 ** 18 * 10000000) 108 result = client_new_node.delegate.delegate(0, address1) 109 log.info(result) 110 111 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 112 staking_blocknum = msg["Ret"]["StakingBlockNum"] 113 # Return a pledge 114 client_new_node.staking.withdrew_staking(address) 115 116 # The next two cycle 117 client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=2) 118 amount1 = client_new_node.node.eth.getBalance(address1) 119 log.info("The wallet balance:{}".format(amount1)) 120 121 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1) 122 assert_code(result, 0) 123 amount2 = client_new_node.node.eth.getBalance(address1) 124 log.info("The wallet balance:{}".format(amount2)) 125 delegate_limit = client_new_node.economic.delegate_limit 126 assert delegate_limit - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 127 128 129 @pytest.mark.P1 130 def test_ROE_006_008(client_new_node): 131 """ 132 133 :param client_new_node_obj: 134 :return: 135 """ 136 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 137 10 ** 18 * 10000000) 138 client_new_node.staking.create_staking(0, address, address) 139 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 140 10 ** 18 * 10000000) 141 value = client_new_node.economic.delegate_limit * 3 142 result = client_new_node.delegate.delegate(0, address1, amount=value) 143 log.info(result) 144 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 145 staking_blocknum = msg["Ret"]["StakingBlockNum"] 146 value = client_new_node.economic.delegate_limit * 2 147 amount1 = client_new_node.node.eth.getBalance(address1) 148 log.info("The wallet balance:{}".format(amount1)) 149 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1, amount=value) 150 assert_code(result, 0) 151 amount2 = client_new_node.node.eth.getBalance(address1) 152 log.info("The wallet balance:{}".format(amount2)) 153 154 155 @pytest.mark.P1 156 def test_ROE_010(client_new_node): 157 """ 158 :param client_new_node_obj: 159 :return: 160 """ 161 client_new_node.economic.env.deploy_all() 162 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 163 10 ** 18 * 10000000) 164 lockup_amount = client_new_node.node.web3.toWei(1000, "ether") 165 plan = [{'Epoch': 1, 'Amount': lockup_amount}] 166 # Create a lock plan 167 result = client_new_node.restricting.createRestrictingPlan(address, plan, address) 168 log.info(result) 169 assert_code(result, 0) 170 msg = client_new_node.ppos.getRestrictingInfo(address) 171 log.info(msg) 172 # create staking 173 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 174 10 ** 18 * 10000000) 175 client_new_node.staking.create_staking(0, address_staking, address_staking) 176 177 delegate_amount = client_new_node.node.web3.toWei(500, "ether") 178 # Lock account authorization 179 result = client_new_node.delegate.delegate(1, address, amount=delegate_amount) 180 log.info(result) 181 # Own capital account entrustment 182 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount) 183 log.info(result) 184 185 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 186 staking_blocknum = msg["Ret"]["StakingBlockNum"] 187 188 undelegate_amount = client_new_node.node.web3.toWei(300, "ether") 189 log.info("The amount of redemption is greater than the entrustment of the free account") 190 amount1 = client_new_node.node.eth.getBalance(address) 191 log.info("The wallet balance:{}".format(amount1)) 192 193 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount) 194 assert_code(result, 0) 195 196 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id) 197 log.info(msg) 198 amount2 = client_new_node.node.eth.getBalance(address) 199 log.info("The wallet balance:{}".format(amount2)) 200 assert undelegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 201 202 203 @pytest.mark.P1 204 def test_ROE_011(client_new_node): 205 """ 206 207 :param client_new_node_obj: 208 :return: 209 """ 210 client_new_node.economic.env.deploy_all() 211 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 212 10 ** 18 * 10000000) 213 lockup_amount = client_new_node.node.web3.toWei(1000, "ether") 214 plan = [{'Epoch': 1, 'Amount': lockup_amount}] 215 # Create a lock plan 216 result = client_new_node.restricting.createRestrictingPlan(address, plan, address) 217 log.info(result) 218 assert_code(result, 0) 219 msg = client_new_node.ppos.getRestrictingInfo(address) 220 log.info(msg) 221 # create staking 222 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 223 10 ** 18 * 10000000) 224 client_new_node.staking.create_staking(0, address_staking, address_staking) 225 226 delegate_amount = client_new_node.node.web3.toWei(500, "ether") 227 # Lock account authorization 228 result = client_new_node.delegate.delegate(1, address, amount=delegate_amount) 229 log.info(result) 230 # Own capital account entrustment 231 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount) 232 log.info(result) 233 234 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 235 staking_blocknum = msg["Ret"]["StakingBlockNum"] 236 237 undelegate_amount = client_new_node.node.web3.toWei(700, "ether") 238 log.info("The amount of redemption is greater than the entrustment of the free account") 239 amount1 = client_new_node.node.eth.getBalance(address) 240 log.info("The wallet balance:{}".format(amount1)) 241 242 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount) 243 assert_code(result, 0) 244 245 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id) 246 log.info(msg) 247 amount2 = client_new_node.node.eth.getBalance(address) 248 log.info("The wallet balance:{}".format(amount2)) 249 assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 250 # The next cycle 251 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 252 locked_delegate = delegate_amount - (undelegate_amount - delegate_amount) 253 msg = client_new_node.ppos.getRestrictingInfo(address) 254 log.info(msg) 255 # The remaining entrusted amount 256 assert msg["Ret"]["Pledge"] == locked_delegate 257 amount3 = client_new_node.node.eth.getBalance(address) 258 log.info("The wallet balance:{}".format(amount3)) 259 assert amount3 - amount2 == lockup_amount - msg["Ret"]["debt"] 260 261 262 @pytest.mark.P1 263 def test_ROE_012(client_new_node): 264 """ 265 :param client_new_node_obj: 266 :return: 267 """ 268 # create staking 269 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 270 10 ** 18 * 10000000) 271 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 272 10 ** 18 * 10000000) 273 client_new_node.staking.create_staking(0, address_staking, address_staking) 274 delegate_amount = client_new_node.node.web3.toWei(50, "ether") 275 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount) 276 log.info(result) 277 amount1 = client_new_node.node.eth.getBalance(address) 278 log.info("The wallet balance:{}".format(amount1)) 279 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 280 staking_blocknum = msg["Ret"]["StakingBlockNum"] 281 # After redemptive balance is less than the threshold that entrusts gold, redeem completely 282 undelegate_amount = client_new_node.node.web3.toWei(41, "ether") 283 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount) 284 assert_code(result, 0) 285 amount2 = client_new_node.node.eth.getBalance(address) 286 log.info("The wallet balance:{}".format(amount2)) 287 assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 288 289 290 @pytest.mark.P1 291 def test_ROE_014(client_new_node): 292 """ 293 :param client_new_node_obj: 294 :return: 295 """ 296 client_new_node.economic.env.deploy_all() 297 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 298 10 ** 18 * 10000000) 299 lockup_amount = client_new_node.node.web3.toWei(1000, "ether") 300 plan = [{'Epoch': 1, 'Amount': lockup_amount}] 301 # Create a lock plan 302 result = client_new_node.restricting.createRestrictingPlan(address, plan, address) 303 log.info(result) 304 assert_code(result, 0) 305 msg = client_new_node.ppos.getRestrictingInfo(address) 306 log.info(msg) 307 # create staking 308 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 309 10 ** 18 * 10000000) 310 client_new_node.staking.create_staking(0, address_staking, address_staking) 311 312 delegate_amount = client_new_node.node.web3.toWei(1000, "ether") 313 # Lock account authorization 314 result = client_new_node.delegate.delegate(1, address, amount=delegate_amount) 315 log.info(result) 316 # Own capital account entrustment 317 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount) 318 log.info(result) 319 320 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 321 staking_blocknum = msg["Ret"]["StakingBlockNum"] 322 value = 1000 * 2 - 9 323 undelegate_amount = client_new_node.node.web3.toWei(value, "ether") 324 amount1 = client_new_node.node.eth.getBalance(address) 325 log.info("The wallet balance:{}".format(amount1)) 326 327 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount) 328 assert_code(result, 0) 329 330 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id) 331 log.info(msg) 332 amount2 = client_new_node.node.eth.getBalance(address) 333 log.info("The wallet balance:{}".format(amount2)) 334 account_dill = amount2 - amount1 335 assert delegate_amount - account_dill < client_new_node.node.web3.toWei(1, "ether") 336 337 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 338 amount3 = client_new_node.node.eth.getBalance(address) 339 log.info("The wallet balance:{}".format(amount3)) 340 assert amount3 - amount2 == delegate_amount 341 342 343 @pytest.mark.P1 344 def test_ROE_017(client_new_node): 345 """ 346 347 :param client_new_node_obj: 348 :return: 349 """ 350 client_new_node.economic.env.deploy_all() 351 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 352 10 ** 18 * 10000000) 353 lockup_amount = client_new_node.node.web3.toWei(500, "ether") 354 plan = [{'Epoch': 1, 'Amount': lockup_amount}] 355 # Create a lock plan 356 result = client_new_node.restricting.createRestrictingPlan(address, plan, address) 357 log.info(result) 358 assert_code(result, 0) 359 msg = client_new_node.ppos.getRestrictingInfo(address) 360 log.info(msg) 361 # create staking 362 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 363 10 ** 18 * 10000000) 364 client_new_node.staking.create_staking(0, address_staking, address_staking) 365 366 delegate_amount = client_new_node.node.web3.toWei(500, "ether") 367 # Lock account authorization 368 result = client_new_node.delegate.delegate(1, address, amount=delegate_amount) 369 log.info(result) 370 # Own capital account entrustment 371 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount) 372 log.info(result) 373 374 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 375 staking_blocknum = msg["Ret"]["StakingBlockNum"] 376 # Redemptive amount is equal to free account + the entrustment gold of lock storehouse 377 378 undelegate_amount = client_new_node.node.web3.toWei(1000, "ether") 379 amount1 = client_new_node.node.eth.getBalance(address) 380 log.info("The wallet balance:{}".format(amount1)) 381 382 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount) 383 assert_code(result, 0) 384 385 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id) 386 log.info(msg) 387 amount2 = client_new_node.node.eth.getBalance(address) 388 log.info("The wallet balance:{}".format(amount2)) 389 assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 390 391 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 392 393 msg = client_new_node.ppos.getRestrictingInfo(address) 394 log.info(msg) 395 amount3 = client_new_node.node.eth.getBalance(address) 396 log.info("The wallet balance:{}".format(amount3)) 397 assert amount3 - amount2 == delegate_amount 398 399 400 @pytest.mark.P1 401 def test_ROE_019_021(client_new_node): 402 """ 403 404 :param client_new_node_obj: 405 :return: 406 """ 407 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 408 10 ** 18 * 10000000) 409 client_new_node.staking.create_staking(0, address, address) 410 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 411 10 ** 18 * 10000000) 412 value = client_new_node.economic.delegate_limit * 3 413 result = client_new_node.delegate.delegate(0, address1, amount=value) 414 log.info(result) 415 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 416 staking_blocknum = msg["Ret"]["StakingBlockNum"] 417 value = client_new_node.economic.delegate_limit * 2 418 amount1 = client_new_node.node.eth.getBalance(address1) 419 log.info("The wallet balance:{}".format(amount1)) 420 421 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 422 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1, amount=value) 423 assert_code(result, 0) 424 amount2 = client_new_node.node.eth.getBalance(address1) 425 log.info("The wallet balance:{}".format(amount2)) 426 assert value - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 427 428 429 @pytest.mark.P0 430 def test_ROE_020(client_new_node): 431 """ 432 :param client_new_node_obj: 433 :return: 434 """ 435 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 436 10 ** 18 * 10000000) 437 client_new_node.staking.create_staking(0, address, address) 438 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 439 10 ** 18 * 10000000) 440 441 result = client_new_node.delegate.delegate(0, address1) 442 log.info(result) 443 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 444 staking_blocknum = msg["Ret"]["StakingBlockNum"] 445 amount1 = client_new_node.node.eth.getBalance(address1) 446 log.info("The wallet balance:{}".format(amount1)) 447 448 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 449 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1) 450 assert_code(result, 0) 451 amount2 = client_new_node.node.eth.getBalance(address1) 452 log.info("The wallet balance:{}".format(amount2)) 453 delegate_limit = client_new_node.economic.delegate_limit 454 assert delegate_limit - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 455 456 457 @pytest.mark.P1 458 def test_ROE_024(client_new_node): 459 """ 460 461 :param client_new_node_obj: 462 :return: 463 """ 464 client_new_node.economic.env.deploy_all() 465 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 466 10 ** 18 * 10000000) 467 lockup_amount = client_new_node.node.web3.toWei(1000, "ether") 468 plan = [{'Epoch': 2, 'Amount': lockup_amount}] 469 # Create a lock plan 470 result = client_new_node.restricting.createRestrictingPlan(address, plan, address) 471 log.info(result) 472 assert_code(result, 0) 473 msg = client_new_node.ppos.getRestrictingInfo(address) 474 log.info(msg) 475 # create staking 476 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 477 10 ** 18 * 10000000) 478 client_new_node.staking.create_staking(0, address_staking, address_staking) 479 480 delegate_amount = client_new_node.node.web3.toWei(500, "ether") 481 # Lock account authorization 482 result = client_new_node.delegate.delegate(1, address, amount=delegate_amount) 483 log.info(result) 484 # Own capital account entrustment 485 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount) 486 log.info(result) 487 # The next cycle 488 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 489 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 490 staking_blocknum = msg["Ret"]["StakingBlockNum"] 491 492 undelegate_amount = client_new_node.node.web3.toWei(700, "ether") 493 log.info("The amount of redemption is greater than the entrustment of the free account") 494 amount1 = client_new_node.node.eth.getBalance(address) 495 log.info("The wallet balance:{}".format(amount1)) 496 497 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount) 498 assert_code(result, 0) 499 500 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id) 501 log.info(msg) 502 amount2 = client_new_node.node.eth.getBalance(address) 503 log.info("The wallet balance:{}".format(amount2)) 504 assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 505 506 # The next cycle 507 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 508 locked_delegate = delegate_amount - (undelegate_amount - delegate_amount) 509 msg = client_new_node.ppos.getRestrictingInfo(address) 510 log.info(msg) 511 assert msg["Ret"]["Pledge"] == locked_delegate 512 amount3 = client_new_node.node.eth.getBalance(address) 513 log.info("The wallet balance:{}".format(amount3)) 514 assert amount3 - amount2 == lockup_amount - msg["Ret"]["debt"] 515 516 517 @pytest.mark.P1 518 def test_ROE_028(client_new_node): 519 """ 520 :param client_new_node_bgj: 521 :return: 522 """ 523 # create staking 524 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 525 10 ** 18 * 10000000) 526 client_new_node.staking.create_staking(0, address_staking, address_staking) 527 delegate_amount = client_new_node.node.web3.toWei(500, "ether") 528 529 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 530 10 ** 18 * 10000000) 531 # create delegate 532 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount) 533 log.info(result) 534 535 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 536 staking_blocknum = msg["Ret"]["StakingBlockNum"] 537 538 amount1 = client_new_node.node.eth.getBalance(address) 539 log.info("The wallet balance:{}".format(amount1)) 540 # The next cycle 541 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 542 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=delegate_amount) 543 assert_code(result, 0) 544 545 amount2 = client_new_node.node.eth.getBalance(address) 546 log.info("The wallet balance:{}".format(amount2)) 547 assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 548 549 550 @pytest.mark.P1 551 def test_ROE_030(client_new_node): 552 """ 553 554 :param client_new_node_obj: 555 :return: 556 """ 557 client_new_node.economic.env.deploy_all() 558 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 559 10 ** 18 * 10000000) 560 lockup_amount = client_new_node.node.web3.toWei(500, "ether") 561 plan = [{'Epoch': 2, 'Amount': lockup_amount}] 562 # Create a lock plan 563 result = client_new_node.restricting.createRestrictingPlan(address, plan, address) 564 log.info(result) 565 assert_code(result, 0) 566 msg = client_new_node.ppos.getRestrictingInfo(address) 567 log.info(msg) 568 # create staking 569 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 570 10 ** 18 * 10000000) 571 client_new_node.staking.create_staking(0, address_staking, address_staking) 572 573 delegate_amount = client_new_node.node.web3.toWei(500, "ether") 574 # Lock account authorization 575 result = client_new_node.delegate.delegate(1, address, amount=delegate_amount) 576 log.info(result) 577 # Own capital account entrustment 578 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount) 579 log.info(result) 580 # The next cycle 581 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 582 583 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 584 staking_blocknum = msg["Ret"]["StakingBlockNum"] 585 # Redemptive amount is equal to free account + the entrustment gold of lock storehouse 586 587 undelegate_amount = client_new_node.node.web3.toWei(1000, "ether") 588 amount1 = client_new_node.node.eth.getBalance(address) 589 log.info("The wallet balance:{}".format(amount1)) 590 591 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount) 592 assert_code(result, 0) 593 594 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id) 595 log.info(msg) 596 amount2 = client_new_node.node.eth.getBalance(address) 597 log.info("The wallet balance:{}".format(amount2)) 598 assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 599 600 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 601 602 msg = client_new_node.ppos.getRestrictingInfo(address) 603 log.info(msg) 604 amount3 = client_new_node.node.eth.getBalance(address) 605 log.info("The wallet balance:{}".format(amount3)) 606 assert amount3 - amount2 == delegate_amount 607 608 609 @pytest.mark.P1 610 def test_ROE_042(client_new_node): 611 """ 612 613 :param client_new_node_obj: 614 :return: 615 """ 616 client_new_node.economic.env.deploy_all() 617 618 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 619 10 ** 18 * 10000000) 620 lockup_amount = client_new_node.node.web3.toWei(1000, "ether") 621 plan = [{'Epoch': 2, 'Amount': lockup_amount}] 622 # Create a lock plan 623 result = client_new_node.restricting.createRestrictingPlan(address, plan, address) 624 log.info(result) 625 assert_code(result, 0) 626 msg = client_new_node.ppos.getRestrictingInfo(address) 627 log.info(msg) 628 # create staking 629 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 630 10 ** 18 * 10000000) 631 client_new_node.staking.create_staking(0, address_staking, address_staking) 632 633 delegate_amount = client_new_node.node.web3.toWei(200, "ether") 634 # Lock account authorization 635 result = client_new_node.delegate.delegate(1, address, amount=delegate_amount) 636 log.info(result) 637 # Own capital account entrustment 638 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount) 639 log.info(result) 640 641 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 642 staking_blocknum = msg["Ret"]["StakingBlockNum"] 643 644 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id) 645 log.info(msg) 646 # The next cycle 647 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 648 649 delegate_amount_2 = client_new_node.node.web3.toWei(300, "ether") 650 result = client_new_node.delegate.delegate(1, address, amount=delegate_amount_2) 651 log.info(result) 652 # Own capital account entrustment 653 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount_2) 654 log.info(result) 655 656 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id) 657 log.info(msg) 658 659 undelegate_amount = client_new_node.node.web3.toWei(700, "ether") 660 amount1 = client_new_node.node.eth.getBalance(address) 661 log.info("The wallet balance:{}".format(amount1)) 662 log.info("Redemption is more than the hesitation period of the own amount + lock amount") 663 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount) 664 assert_code(result, 0) 665 666 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id) 667 log.info(msg) 668 amount2 = client_new_node.node.eth.getBalance(address) 669 log.info("The wallet balance:{}".format(amount2)) 670 """赎回金额700，先赎回自由金额300，锁仓金额300，再赎回自由金额的100；目前锁定期的自由资金立马退，所以退400""" 671 account_dill = undelegate_amount - delegate_amount_2 * 2 672 account_sum = account_dill + delegate_amount_2 673 assert amount2 - amount1 > account_sum - client_new_node.node.web3.toWei(1, "ether") 674 675 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 676 677 msg = client_new_node.ppos.getRestrictingInfo(address) 678 log.info(msg) 679 amount3 = client_new_node.node.eth.getBalance(address) 680 log.info("The wallet balance:{}".format(amount3)) 681 assert amount3 - amount2 == lockup_amount - msg["Ret"]["debt"] 682 683 684 @pytest.mark.P1 685 def test_ROE_055(client_new_node): 686 """ 687 :param client_new_node_obj: 688 :return: 689 """ 690 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 691 10 ** 18 * 10000000) 692 client_new_node.staking.create_staking(0, address_staking, address_staking) 693 delegate_amount = client_new_node.node.web3.toWei(500, "ether") 694 695 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 696 10 ** 18 * 10000000) 697 # create delegate 698 result = client_new_node.delegate.delegate(0, address, amount=delegate_amount) 699 log.info(result) 700 701 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 702 staking_blocknum = msg["Ret"]["StakingBlockNum"] 703 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=delegate_amount + 1) 704 assert_code(result, 301113) 705 706 707 @pytest.mark.P1 708 def test_ROE_056_057(client_new_node, client_consensus): 709 """ 710 711 :param client_new_node_obj: 712 :param client_consensus_obj: 713 :return: 714 """ 715 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 716 10 ** 18 * 10000000) 717 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 718 10 ** 18 * 10000000) 719 value = client_new_node.economic.create_staking_limit * 2 720 result = client_new_node.staking.create_staking(0, address_staking, address_staking, 721 amount=value) 722 assert_code(result, 0) 723 724 # create delegate 725 result = client_new_node.delegate.delegate(0, address) 726 log.info(result) 727 728 log.info("Close one node") 729 client_new_node.node.stop() 730 node = client_consensus.node 731 732 msg = client_consensus.ppos.getCandidateInfo(client_new_node.node.node_id) 733 staking_blocknum = msg["Ret"]["StakingBlockNum"] 734 log.info("The next two periods") 735 client_consensus.economic.wait_settlement_blocknum(node, number=2) 736 737 log.info("Restart the node") 738 client_new_node.node.start() 739 amount1 = client_new_node.node.eth.getBalance(address) 740 log.info("The wallet balance:{}".format(amount1)) 741 742 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address) 743 log.info(result) 744 745 amount2 = client_new_node.node.eth.getBalance(address) 746 log.info("The wallet balance:{}".format(amount2)) 747 delegate_limit = client_new_node.economic.delegate_limit 748 assert delegate_limit - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether") 749 750 751 @pytest.mark.P3 752 def test_ROE_058(client_new_node): 753 """ 754 :param client_new_node_obj: 755 :return: 756 """ 757 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 758 10 ** 18 * 10000000) 759 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 760 10 ** 18 * 10000000) 761 result = client_new_node.staking.create_staking(0, address_staking, address_staking) 762 assert_code(result, 0) 763 764 result = client_new_node.delegate.delegate(0, address) 765 log.info(result) 766 767 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 768 staking_blocknum = msg["Ret"]["StakingBlockNum"] 769 770 amount = client_new_node.node.eth.getBalance(address) 771 log.info("The wallet balance:{}".format(amount)) 772 cfg = {"gasPrice": amount} 773 status = 0 774 try: 775 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, transaction_cfg=cfg) 776 log.info(result) 777 except BaseException: 778 status = 1 779 assert status == 1 780 781 782 @pytest.mark.P3 783 def test_ROE_059(client_new_node): 784 """ 785 :param client_new_node_obj: 786 :return: 787 """ 788 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 789 10 ** 18 * 10000000) 790 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 791 10 ** 18 * 10000000) 792 result = client_new_node.staking.create_staking(0, address_staking, address_staking) 793 assert_code(result, 0) 794 795 result = client_new_node.delegate.delegate(0, address) 796 log.info(result) 797 798 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 799 staking_blocknum = msg["Ret"]["StakingBlockNum"] 800 801 cfg = {"gas": 10} 802 status = 0 803 try: 804 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, transaction_cfg=cfg) 805 log.info(result) 806 except BaseException: 807 status = 1 808 assert status == 1 809 810 811 @pytest.mark.P1 812 def test_ROE_060(client_new_node): 813 """ 814 815 :param client_new_node_obj: 816 :return: 817 """ 818 address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 819 10 ** 18 * 10000000) 820 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 821 10 ** 18 * 10000000) 822 # The next cycle 823 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 824 825 result = client_new_node.staking.create_staking(0, address_staking, address_staking) 826 assert_code(result, 0) 827 828 result = client_new_node.staking.withdrew_staking(address_staking) 829 assert_code(result, 0) 830 # The next two cycle 831 client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=2) 832 # Pledge again after quitting pledge 833 result = client_new_node.staking.create_staking(0, address_staking, address_staking) 834 assert_code(result, 0) 835 result = client_new_node.delegate.delegate(0, address) 836 assert_code(result, 0) 837 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 838 staking_blocknum = msg["Ret"]["StakingBlockNum"] 839 amount1 = client_new_node.node.eth.getBalance(address) 840 log.info("The wallet balance:{}".format(amount1)) 841 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address) 842 log.info(result) 843 assert_code(result, 0) 844 amount2 = client_new_node.node.eth.getBalance(address) 845 log.info("The wallet balance:{}".format(amount2)) 846 delegate_limit = client_new_node.economic.delegate_limit 847 assert delegate_limit - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")