github.com/platonnetwork/platon-go@v0.7.6/cases/tests/ppos_2/test_withdrewDelegate2.py (about) 1 # -*- coding: utf-8 -*- 2 from tests.lib.utils import * 3 import pytest 4 5 6 # Undo delegate use cases from 031 to 049 7 8 9 @pytest.mark.P2 10 def test_ROE_031(staking_delegate_client): 11 """ 12 :param client_new_node: 13 :return: 14 """ 15 client = staking_delegate_client 16 delegate_address = client.delegate_address 17 node = client.node 18 economic = client.economic 19 # Return a pledge 20 client.staking.withdrew_staking(client.staking_address) 21 # The next cycle 22 client.economic.wait_settlement_blocknum(node) 23 result = client.delegate.delegate(0, delegate_address) 24 log.info(result) 25 # The next two cycle 26 client.economic.wait_settlement_blocknum(node, number=2) 27 balance1 = client.node.eth.getBalance(delegate_address) 28 log.info("The wallet balance:{}".format(balance1)) 29 30 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address) 31 assert_code(result, 0) 32 balance2 = client.node.eth.getBalance(delegate_address) 33 log.info("The wallet balance:{}".format(balance2)) 34 delegate_limit = economic.delegate_limit 35 assert delegate_limit - (balance2 - balance1) < node.web3.toWei(1, "ether") 36 37 38 @pytest.mark.P2 39 def test_ROE_032_035(staking_delegate_client): 40 client = staking_delegate_client 41 delegate_address = client.delegate_address 42 node = client.node 43 economic = client.economic 44 log.info("The next cycle") 45 economic.wait_settlement_blocknum(node) 46 result = client.delegate.delegate(0, delegate_address, amount=client.delegate_amount * 2) 47 assert_code(result, 0) 48 balance1 = node.eth.getBalance(delegate_address) 49 log.info("Wallet balance{}".format(balance1)) 50 amount = client.delegate_amount * 2 + node.web3.toWei(1, "ether") 51 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address, 52 amount=amount) 53 assert_code(result, 0) 54 balance2 = node.eth.getBalance(delegate_address) 55 log.info("Wallet balance{}".format(balance2)) 56 assert amount - (balance2 - balance1) < node.web3.toWei(1, "ether") 57 58 59 @pytest.mark.P2 60 def test_ROE_033_034(staking_delegate_client): 61 client = staking_delegate_client 62 delegate_address = client.delegate_address 63 node = client.node 64 economic = client.economic 65 log.info("The next cycle") 66 economic.wait_settlement_blocknum(node) 67 result = client.delegate.delegate(0, delegate_address) 68 assert_code(result, 0) 69 balance1 = node.eth.getBalance(delegate_address) 70 log.info("Wallet balance{}".format(balance1)) 71 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address) 72 assert_code(result, 0) 73 balance2 = node.eth.getBalance(delegate_address) 74 log.info("Wallet balance{}".format(balance2)) 75 assert client.delegate_amount - (balance2 - balance1) < node.web3.toWei(1, "ether") 76 77 78 @pytest.mark.P2 79 def test_ROE_038(staking_delegate_client): 80 client = staking_delegate_client 81 delegate_address = client.delegate_address 82 node = client.node 83 economic = client.economic 84 log.info("The next cycle") 85 economic.wait_settlement_blocknum(node) 86 lockup_amount = client.node.web3.toWei(20, "ether") 87 plan = [{'Epoch': 1, 'Amount': lockup_amount}] 88 # Create a lock plan 89 result = client.restricting.createRestrictingPlan(delegate_address, plan, delegate_address) 90 assert_code(result, 0) 91 result = client.delegate.delegate(1, delegate_address) 92 assert_code(result, 0) 93 result = client.delegate.delegate(0, delegate_address) 94 assert_code(result, 0) 95 balance1 = node.eth.getBalance(delegate_address) 96 log.info("Wallet balance{}".format(balance1)) 97 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address) 98 assert_code(result, 0) 99 balance2 = node.eth.getBalance(delegate_address) 100 log.info("Wallet balance{}".format(balance2)) 101 msg = client.ppos.getRestrictingInfo(delegate_address) 102 log.info(msg) 103 delegate_limit = client.delegate_amount 104 assert delegate_limit - (balance2 - balance1) < node.web3.toWei(1, "ether") 105 assert msg["Ret"]["Pledge"] == delegate_limit 106 107 108 @pytest.mark.P2 109 def test_ROE_039(staking_delegate_client): 110 client = staking_delegate_client 111 delegate_address = client.delegate_address 112 node = client.node 113 economic = client.economic 114 log.info("The next cycle") 115 economic.wait_settlement_blocknum(node) 116 lockup_amount = client.node.web3.toWei(20, "ether") 117 plan = [{'Epoch': 1, 'Amount': lockup_amount}] 118 # Create a lock plan 119 result = client.restricting.createRestrictingPlan(delegate_address, plan, delegate_address) 120 assert_code(result, 0) 121 result = client.delegate.delegate(1, delegate_address, amount=client.delegate_amount * 2) 122 assert_code(result, 0) 123 result = client.delegate.delegate(0, delegate_address) 124 assert_code(result, 0) 125 msg = client.ppos.getDelegateInfo(client.staking_blocknum, delegate_address, node.node_id) 126 log.info(msg) 127 balance1 = node.eth.getBalance(delegate_address) 128 log.info("Wallet balance{}".format(balance1)) 129 amount = client.delegate_amount * 2 130 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address, 131 amount=amount) 132 assert_code(result, 0) 133 balance2 = node.eth.getBalance(delegate_address) 134 log.info("Wallet balance{}".format(balance2)) 135 msg = client.ppos.getRestrictingInfo(delegate_address) 136 log.info(msg) 137 assert client.delegate_amount - (balance2 - balance1) < node.web3.toWei(1, "ether") 138 assert msg["Ret"]["Pledge"] == client.delegate_amount 139 140 141 @pytest.mark.P2 142 def test_ROE_040(free_locked_delegate_client): 143 client = free_locked_delegate_client 144 delegate_address = client.delegate_address 145 node = client.node 146 balance1 = node.eth.getBalance(delegate_address) 147 log.info("Wallet balance{}".format(balance1)) 148 amount = client.delegate_amount * 2 + client.node.web3.toWei(1, "ether") 149 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address, 150 amount=amount) 151 assert_code(result, 0) 152 balance2 = node.eth.getBalance(delegate_address) 153 log.info("Wallet balance{}".format(balance2)) 154 assert client.delegate_amount * 2 - (balance2 - balance1) < node.web3.toWei(1, "ether") 155 msg = client.ppos.getRestrictingInfo(delegate_address) 156 log.info(msg) 157 assert msg["Ret"]["Pledge"] == 0 158 159 160 @pytest.mark.P2 161 def test_ROE_041(free_locked_delegate_client): 162 client = free_locked_delegate_client 163 delegate_address = client.delegate_address 164 node = client.node 165 balance1 = node.eth.getBalance(delegate_address) 166 log.info("Wallet balance{}".format(balance1)) 167 amount = client.delegate_amount * 3 168 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address, 169 amount=amount) 170 assert_code(result, 0) 171 balance2 = node.eth.getBalance(delegate_address) 172 log.info("Wallet balance{}".format(balance2)) 173 msg = client.ppos.getRestrictingInfo(delegate_address) 174 log.info(msg) 175 assert client.delegate_amount * 2 - (balance2 - balance1) < node.web3.toWei(1, "ether") 176 177 178 @pytest.mark.P2 179 def test_ROE_042(free_locked_delegate_client): 180 client = free_locked_delegate_client 181 delegate_address = client.delegate_address 182 node = client.node 183 economic = client.economic 184 log.info("The next cycle") 185 economic.wait_settlement_blocknum(node) 186 result = client.delegate.delegate(0, delegate_address) 187 assert_code(result, 0) 188 balance1 = node.eth.getBalance(delegate_address) 189 log.info("Wallet balance{}".format(balance1)) 190 amount = client.delegate_amount * 3 + node.web3.toWei(5, "ether") 191 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address, 192 amount=amount) 193 assert_code(result, 0) 194 balance2 = node.eth.getBalance(delegate_address) 195 log.info("Wallet balance{}".format(balance2)) 196 msg = client.ppos.getRestrictingInfo(delegate_address) 197 log.info(msg) 198 assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether") 199 assert msg["Ret"]["Pledge"] == 0 200 201 202 @pytest.mark.P2 203 def test_ROE_043(free_locked_delegate_client): 204 client = free_locked_delegate_client 205 delegate_address = client.delegate_address 206 node = client.node 207 economic = client.economic 208 log.info("The next cycle") 209 economic.wait_settlement_blocknum(node) 210 result = client.delegate.delegate(0, delegate_address) 211 assert_code(result, 0) 212 result = client.delegate.delegate(1, delegate_address) 213 assert_code(result, 0) 214 balance1 = node.eth.getBalance(delegate_address) 215 log.info("Wallet balance{}".format(balance1)) 216 amount = client.delegate_amount * 4 217 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address, 218 amount=amount) 219 assert_code(result, 0) 220 balance2 = node.eth.getBalance(delegate_address) 221 log.info("Wallet balance{}".format(balance2)) 222 msg = client.ppos.getRestrictingInfo(delegate_address) 223 log.info(msg) 224 assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether") 225 assert msg["Ret"]["Pledge"] == client.delegate_amount 226 227 228 @pytest.mark.P2 229 def test_ROE_044(free_locked_delegate_client): 230 client = free_locked_delegate_client 231 delegate_address = client.delegate_address 232 node = client.node 233 economic = client.economic 234 log.info("The next cycle") 235 economic.wait_settlement_blocknum(node) 236 result = client.delegate.delegate(0, delegate_address) 237 assert_code(result, 0) 238 result = client.delegate.delegate(1, delegate_address) 239 assert_code(result, 0) 240 balance1 = node.eth.getBalance(delegate_address) 241 log.info("Wallet balance{}".format(balance1)) 242 amount = client.delegate_amount * 4 + node.web3.toWei(5, "ether") 243 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address, 244 amount=amount) 245 assert_code(result, 0) 246 balance2 = node.eth.getBalance(delegate_address) 247 log.info("Wallet balance{}".format(balance2)) 248 msg = client.ppos.getRestrictingInfo(delegate_address) 249 log.info(msg) 250 log.info("Wallet balance{}".format(balance2)) 251 assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether") 252 assert msg["Ret"]["Pledge"] == 0 253 254 255 @pytest.mark.P2 256 def test_ROE_045(staking_delegate_client): 257 client = staking_delegate_client 258 delegate_address = client.delegate_address 259 node = client.node 260 economic = client.economic 261 log.info("The next cycle") 262 economic.wait_settlement_blocknum(node) 263 result = client.delegate.delegate(0, delegate_address) 264 assert_code(result, 0) 265 balance1 = node.eth.getBalance(delegate_address) 266 log.info("Wallet balance{}".format(balance1)) 267 amount = client.delegate_amount * 3 - node.web3.toWei(1, "ether") 268 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address, 269 amount=amount) 270 assert_code(result, 0) 271 balance2 = node.eth.getBalance(delegate_address) 272 log.info("Wallet balance{}".format(balance2)) 273 assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether") 274 275 276 @pytest.mark.P2 277 def test_ROE_048(staking_delegate_client): 278 client = staking_delegate_client 279 delegate_address = client.delegate_address 280 node = client.node 281 economic = client.economic 282 log.info("The next cycle") 283 economic.wait_settlement_blocknum(node) 284 result = client.delegate.delegate(0, delegate_address) 285 assert_code(result, 0) 286 balance1 = node.eth.getBalance(delegate_address) 287 log.info("Wallet balance{}".format(balance1)) 288 amount = client.delegate_amount * 3 - node.web3.toWei(1, "ether") 289 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address, 290 amount=amount) 291 assert_code(result, 0) 292 balance2 = node.eth.getBalance(delegate_address) 293 log.info("Wallet balance{}".format(balance2)) 294 msg = client.ppos.getRestrictingInfo(delegate_address) 295 log.info(msg) 296 assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether") 297 298 299 @pytest.mark.P2 300 def test_ROE_049(staking_delegate_client): 301 client = staking_delegate_client 302 delegate_address = client.delegate_address 303 node = client.node 304 economic = client.economic 305 log.info("The next cycle") 306 economic.wait_settlement_blocknum(node) 307 lockup_amount = client.node.web3.toWei(20, "ether") 308 plan = [{'Epoch': 1, 'Amount': lockup_amount}] 309 # Create a lock plan 310 result = client.restricting.createRestrictingPlan(delegate_address, plan, delegate_address) 311 assert_code(result, 0) 312 result = client.delegate.delegate(1, delegate_address) 313 assert_code(result, 0) 314 result = client.delegate.delegate(0, delegate_address) 315 assert_code(result, 0) 316 balance1 = node.eth.getBalance(delegate_address) 317 log.info("Wallet balance{}".format(balance1)) 318 amount = client.delegate_amount * 4 319 result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address, 320 amount=amount) 321 assert_code(result, 0) 322 balance2 = node.eth.getBalance(delegate_address) 323 log.info("Wallet balance{}".format(balance2)) 324 msg = client.ppos.getRestrictingInfo(delegate_address) 325 log.info(msg) 326 assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether") 327 assert msg["Ret"]["Pledge"] == 0