def cancel_producers_candidates(self):
global result
for producer in self.register_producers_list:
ret = self.cancel_producer(producer)
if not ret:
return False
rpc.discrete_mining(1)
status = rpc.producer_status(
producer.node.owner_keystore.public_key.hex())
result = status is "Cancelled"
return result
def wait_block(self):
Logger.info("waiting for the block ... ")
count_height = 0
height = self.get_current_height()
while True:
if height + 1 >= count_height:
rpc.discrete_mining(1)
time.sleep(1)
count_height = self.get_current_height()
else:
break
def vote_crc_proposal_candidates(self, crc_proposal_hash: bytes):
vote_amount = 1 * constant.TO_SELA
ret = self.vote_proposal(
input_private_key=self.tap_account.private_key(),
amount=vote_amount,
candidates=[crc_proposal_hash])
if not ret:
return False
rpc.discrete_mining(1)
Logger.info(
"{} vote crc proposal:{} amount:{} on success!\n".format(self.tag, crc_proposal_hash.hex(), vote_amount))
return True
def run_wrong_addr_case(acc: Account, with_draw_times=1):
global output, fee, value, balance
balances_start = get_mainchain_balances([output])
for i in range(with_draw_times):
log_print(
"=================Withdraw for {} time===================".format(
i))
main_addr = output
if i == 1:
log_print(
"This withdraw is use wrong mainchain address: {}".format(
output_wrong))
main_addr = output_wrong
txhash, err = get_receipt_hash(main_addr, balance, fee, value, acc)
if not txhash:
log_print_is_case_pass(False, case_name,
"Call contract methon Fail!" + err)
return
log_print(
"To make sure the address of main chain has received the money, We need to wait main chain mining 151 blocks! "
)
start_height = rpc.get_block_count()
while True:
current_height = rpc.get_block_count()
Logger.info("current height: {}, dest height:{} ".format(
current_height, (start_height + 151)))
if current_height - start_height > 150:
break
# 调用主链出块，要求时间等待3秒，给主链共识
rpc.discrete_mining(1)
time.sleep(3)
balances_end = get_mainchain_balances([output])
addr = output
if with_draw_times > 1:
with_draw_times -= 1
value_term = balance / 1e18 * with_draw_times
fee_term = fee / 1e18 * with_draw_times
if float(balances_start[addr]) + value_term - fee_term - float(
balances_end[addr]) > 0.0:
infostr = "address: " + addr + "balance_start: " + str(
balances_start[addr]) + "balance_end: " + str(
balances_end[addr]) + "withdraw_value: " + str(
value_term) + "fee: " + str(fee_term)
log_print_is_case_pass(
False, "wrong_addr_case",
"Withdraw Fail in balance calc! detail:" + infostr)
return
log_print_is_case_pass(True, "wrong_addr_case")
def vote_producers(self, start: int, end: int):
for i in range(start, end):
producer = self.register_producers_list
vote_amount = constant.TO_SELA
ret = self.vote_producer(input_private_key=self.private_key,
amount=vote_amount,
candidates=[producer])
if not ret:
return False
Logger.info("{} vote node-{} {} Elas on success!\n".format(
self.tag, i, vote_amount))
rpc.discrete_mining(1)
return True
def vote_producers(self, start: int, end: int):
for i in range(start, end):
producer = self.register_producers_list[i - self.params.ela_params.crc_number - 1]
vote_amount = (self.params.ela_params.number - i + 1) * constant.TO_SELA
ret = self.vote_producer(
input_private_key=producer.node_account().private_key(),
amount=vote_amount,
candidates=[producer]
)
if not ret:
return False
Logger.info("{} vote node-{} {} Elas on success!\n".format(self.tag, i, vote_amount))
rpc.discrete_mining(1)
return True
def vote_cr_candidates(self):
for i in range(1, self.params.ela_params.crc_number + 1):
crs = self.register_cr_list[i - 1]
vote_amount = (self.params.ela_params.crc_number - i + 1) * constant.TO_SELA
ret = self.vote_cr(
input_private_key=self.tap_account.private_key(),
amount=vote_amount,
candidates=[crs],
)
if not ret:
return False
rpc.discrete_mining(1)
Logger.info("{} vote CR-{} {} Elas on success!\n".format(self.tag, i, vote_amount))
return True
def mining_side_blocks(self, side_port: int, num=1):
side_height_begin = rpc.get_block_count(side_port)
while True:
main_height = rpc.get_block_count()
side_height = rpc.get_block_count(side_port)
Logger.debug("{} main height: {}, side height: {}".format(
self.tag, main_height, side_height))
if side_height - side_height_begin > num:
break
rpc.discrete_mining(1)
time.sleep(3)
def vote_crc_proposal_candidates(self):
for i in range(len(self.crc_proposal_list)):
proposal = self.crc_proposal_list[i]
vote_amount = (self.params.ela_params.crc_number - i +
1) * constant.TO_SELA
ret = self.vote_proposal(
input_private_key=self.tap_account.private_key(),
amount=vote_amount,
candidates=[proposal])
if not ret:
return False
rpc.discrete_mining(1)
Logger.info("{} vote crc proposal:{} on success!\n".format(
self.tag, proposal.hash, vote_amount))
return True
def recharge_necessary_keystore(self, input_private_key: str, accounts: list, amount: int):
addresses = list()
for a in accounts:
addresses.append(a.address())
ret = self.transfer_asset(input_private_key, addresses, amount)
if ret:
rpc.discrete_mining(1)
else:
Logger.error("{} recharge necessary keystore failed".format(self.tag))
return False
for i in range(len(addresses)):
value = rpc.get_balance_by_address(addresses[i])
Logger.debug("{} arbiter {} wallet balance: {}".format(self.tag, i, value))
return ret
def vote_producers_candidates(self):
for i in range(
self.params.ela_params.crc_number + 1,
self.params.ela_params.number - round(self.params.ela_params.later_start_number / 2) + 1
):
producer = self.register_producers_list[i - self.params.ela_params.crc_number - 1]
vote_amount = (self.params.ela_params.number - i + 1) * constant.TO_SELA
ret = self.vote_producer(
input_private_key=producer.node_private_key(),
amount=vote_amount,
candidates=[producer],
)
if not ret:
return False
rpc.discrete_mining(1)
Logger.info("{} vote node-{} {} Elas on success!\n".format(self.tag, i, vote_amount))
return True
def register_producers(self, start: int, end: int, without_mining=False):
for i in range(start, end):
ela_node = self.node_manager.ela_nodes[i]
ret = self.register_producer(ela_node)
if not ret:
return False
current_height = rpc.get_block_count()
last_height = current_height
while True:
rpc.discrete_mining(1)
current_height = rpc.get_block_count()
Logger.debug("{} current height: {}".format(self.tag, current_height))
if current_height - 6 > last_height:
break
time.sleep(1)
Logger.info("{} register node-{} to be a producer on success!\n".format(self.tag, i))
return True
def register_producers_candidates(self):
global result
result = False
for i in range(
self.params.ela_params.crc_number + 1,
self.params.ela_params.number - round(self.params.ela_params.later_start_number / 2) + 1
):
ela_node = self.node_manager.ela_nodes[i]
public_key = ela_node.node_account.public_key()
ret = self.register_producer(ela_node)
if not ret:
return False
rpc.discrete_mining(7)
status = rpc.producer_status(public_key)
Logger.debug("After mining 7 blocks, register status: {}".format(status))
result = status == "Active"
if not result:
Logger.error("{} register producer {} failed".format(self.tag, ela_node.name))
break
Logger.info("{} register node-{} to be a producer on success!\n".format(self.tag, i))
return result
def mining_blocks_ready(self, foundation_address):
time.sleep(3)
rpc.discrete_mining(110)
balance = rpc.get_balance_by_address(foundation_address)
Logger.info("{} foundation address: {} value: {}".format(
self.tag, foundation_address, balance))
def cross_chain_transaction(self, side_node_type: str, recharge: bool, target_address=""):
if side_node_type is None or side_node_type is "":
return False
global cross_address
global side_port
global result
global balance_port
global cross_input_key
if side_node_type is "did":
side_port = 10136
cross_did_account = self.node_manager.keystore_manager.cross_did_account
cross_address = cross_did_account.address()
cross_input_key = cross_did_account.private_key()
elif side_node_type is "token":
side_port = 10146
cross_token_account = self.node_manager.keystore_manager.cross_token_account
cross_address = cross_token_account.address()
cross_input_key = cross_token_account.private_key()
elif side_node_type is "neo":
side_port = 10156
cross_neo_account = self.node_manager.keystore_manager.cross_neo_account
if target_address == "":
cross_address = cross_neo_account.address()
else:
cross_address = target_address
cross_input_key = cross_neo_account.private_key()
if recharge:
port = self.rpc_port
balance_port = side_port
input_private_key = self.tap_account.private_key()
lock_address = self.params.arbiter_params.side_info[side_node_type][constant.SIDE_RECHARGE_ADDRESS]
amount = 1000 * constant.TO_SELA
else:
port = side_port
balance_port = self.rpc_port
input_private_key = cross_input_key
lock_address = self.params.arbiter_params.side_info[side_node_type][constant.SIDE_WITHDRAW_ADDRESS]
cross_address = self.tap_account.address()
amount = 300 * constant.TO_SELA
balance1 = rpc.get_balance_by_address(cross_address, balance_port)
ret = self.transfer_cross_chain_asset(
input_private_key=input_private_key,
lock_address=lock_address,
cross_address=cross_address,
amount=amount,
recharge=recharge,
port=port
)
if not ret:
Logger.error("{} transfer cross chain asset failed".format(self.tag))
return False
side_height_begin = rpc.get_block_count(side_port)
while True:
main_height = rpc.get_block_count()
side_height = rpc.get_block_count(side_port)
Logger.debug("{} main height: {}, side height: {}".format(self.tag, main_height, side_height))
if side_height - side_height_begin > 10:
break
rpc.discrete_mining(1)
time.sleep(3)
balance2 = rpc.get_balance_by_address(cross_address, balance_port)
Logger.debug("{} recharge balance1: {}".format(self.tag, balance1))
Logger.debug("{} recharge balance2: {}".format(self.tag, balance2))
if isinstance(balance1, dict):
before_balance = list(balance1.values())[0]
else:
before_balance = balance1
if isinstance(balance2, dict):
after_balance = list(balance2.values())[0]
else:
after_balance = balance2
result = (float(after_balance) - float(before_balance)) * constant.TO_SELA > float(amount - 3 * 10000)
Logger.debug("{} recharge result: {}".format(self.tag, result))
return result
def discrete_mining_blocks(num: int):
rpc.discrete_mining(num)
def cross_chain_transaction(self, side_node_type: str, recharge: bool, input_account=None):
if side_node_type is None or side_node_type is "":
return False, None, None, None, None
global cross_key_account
global side_port
global result
global balance_port
if not input_account:
input_account = self.tap_account
if side_node_type is "did":
side_port = 10136
cross_key_account = self.node_manager.keystore_manager.cross_did_account
elif side_node_type is "token":
side_port = 10146
cross_key_account = self.node_manager.keystore_manager.cross_token_account
elif side_node_type is "neo":
side_port = 10156
cross_key_account = self.node_manager.keystore_manager.cross_neo_account
elif side_node_type is "geth":
side_port = 1111
from src.core.nodes.eth import Eth
cross_key_account = Eth.get_random_eth_account()
if recharge:
port = self.rpc_port
balance_port = side_port
input_private_key = input_account.private_key()
lock_address = self.params.arbiter_params.side_info[side_node_type][constant.SIDE_RECHARGE_ADDRESS]
cross_address = cross_key_account.address()
amount = 100 * constant.TO_SELA
else:
port = side_port
balance_port = self.rpc_port
input_private_key = cross_key_account.private_key()
lock_address = self.params.arbiter_params.side_info[side_node_type][constant.SIDE_WITHDRAW_ADDRESS]
cross_address = self.tap_account.address()
amount = 100 * constant.TO_SELA
cross_address = cross_address[2:]
Logger.warn("{} cross address: {}".format(self.tag, cross_address))
balance1 = rpc.get_balance_by_address(cross_address, balance_port, side_node_type)
ret, tx_hash = self.transfer_cross_chain_asset(
input_private_key=input_private_key,
lock_address=lock_address,
cross_address=cross_address,
amount=amount,
recharge=recharge,
port=port
)
if not ret:
Logger.error("{} transfer cross chain asset failed".format(self.tag))
return False, None, None, None, None
side_height_begin = rpc.get_block_count(side_port)
main_height = rpc.get_block_count()
Logger.info(
"To make sure recharge tx be putted into main chain block, we need to wait main chain mining 16 blocks!")
while True:
current_height = rpc.get_block_count()
side_height = rpc.get_block_count(side_port)
Logger.info("{} Current height: {}, dest height: {}".format(self.tag, current_height, (main_height + 16)))
if side_node_type == "geth":
if current_height - main_height > 15:
break
else:
if side_height - side_height_begin > 10:
break
rpc.discrete_mining(1)
time.sleep(3)
balance2 = rpc.get_balance_by_address(cross_address, balance_port, side_node_type)
Logger.debug("{} recharge balance1: {}".format(self.tag, balance1))
Logger.debug("{} recharge balance2: {}".format(self.tag, balance2))
# result = (float(balance2) - float(balance1)) * constant.TO_SELA > float(amount - 3 * 10000)
# Logger.debug("{} recharge result: {}".format(self.tag, result))
#
return True, tx_hash, cross_address, amount, TX_FEE
def discrete_miner(num: int):
while num > 0:
rpc.discrete_mining(1)
num -= 1
time.sleep(0.2)
