def create_side_info(self, node_type: str):
self.params.arbiter_params.side_info[node_type] = dict()
global side_chain_genesis_hash
if node_type is not "geth":
side_port = util.reset_port(1, node_type, "json_port")
Logger.warn("{} side port: {}".format(self.tag, side_port))
side_chain_genesis_hash = rpc.get_block_hash_by_height(
0, side_port)
Logger.debug("{} {} genesis hash: {}".format(
self.tag, node_type,
self.params.arbiter_params.side_chain_genesis_hash))
else:
side_chain_genesis_hash = self.params.eth_params.genesis_hash
recharge_address = keytool.gen_cross_chain_address(
bytes.fromhex(side_chain_genesis_hash))
self.params.arbiter_params.recharge_address = recharge_address
self.params.arbiter_params.withdraw_address = "0000000000000000000000000000000000"
self.params.arbiter_params.side_chain_genesis_hash = side_chain_genesis_hash
Logger.info("{} side genesis hash:{}".format(self.tag,
side_chain_genesis_hash))
Logger.info("{} recharge address: {}".format(
self.tag, self.params.arbiter_params.recharge_address))
Logger.info("{} withdraw address: {}".format(
self.tag, self.params.arbiter_params.withdraw_address))
self.params.arbiter_params.side_info[node_type][
constant.SIDE_GENESIS_ADDRESS] = side_chain_genesis_hash
self.params.arbiter_params.side_info[node_type][
constant.SIDE_RECHARGE_ADDRESS] = recharge_address
self.params.arbiter_params.side_info[node_type][constant.SIDE_WITHDRAW_ADDRESS] = \
self.params.arbiter_params.withdraw_address
def transfer_cross_chain_asset(self, input_private_key: str, lock_address: str, cross_address: str,
amount: int, recharge: bool, port=rpc.DEFAULT_PORT):
tx = txbuild.create_cross_chain_transaction(
input_private_key=input_private_key,
lock_address=lock_address,
cross_chain_address=cross_address,
amount=amount,
recharge=recharge,
rpc_port=port
)
if tx is None:
return False
tx = txbuild.single_sign_transaction(input_private_key, tx)
Logger.warn("cross chain asset transaction: \n{}".format(tx))
ret = self.handle_tx_result(tx, port)
return ret
node.start()
remaining_start = True
if stop_height != 0 and current_height > stop_height + 100:
current_pubkeys = controller.get_current_arbiter_public_keys()
controller.check_result("check all nodes have the same height",
controller.check_nodes_height())
result = set(controller.node_manager.normal_dpos_pubkeys) == set(
current_pubkeys)
break
# mining a block per second
controller.discrete_mining_blocks(1)
time.sleep(1)
# Finally, output the test result and exit
controller.check_result(test_case, result)
if result:
controller.terminate_all_process(result)
if __name__ == '__main__':
for i in range(config["times"]):
Logger.warn("[main] begin testing {} times".format(i + 1))
time.sleep(2)
test_content()
Logger.warn("[main] end testing {} times".format(i + 1))
time.sleep(3)
config = {
"recharge": 1,
"rpc_port": 10016,
"host": "127.0.0.1",
"outputs_num": 1,
"inputs_num": 1,
"block_size": 1,
"pressure_private_key":
"fcbcd369529e4229468ac4f78627467bbe2b6f1c6625b1d9f0f55bf11e638090",
# EM7U5Y8AJcv49pUPQ5jPpt93Nmcwh3ti4Y
"tap_private_key":
"bd758440a858baaff56ec1783388bc44135ed44bb0e4f25ad6cf28be45896d74",
# EWRwrmBWpYFwnvAQffcP1vrPCS5sGTgWEB
"eth_tap_address": "0x53781e106a2e3378083bdcede1874e5c2a7225f8",
"lock_address": "XaKGQrBSAUPF9pAZMz7Ek1S1SdRaw1NfKJ" # eth
#"lock_address":"XKUh4GLhFJiqAMTF6HyWQrV9pK9HcGUdfJ" # did
}
def test_content():
tx = TxControl(config)
tx.get_current_height()
tx.ready_for_pressure_outputs()
tx.ready_for_pressure_cross_chain()
if __name__ == '__main__':
Logger.warn("[main] begin testing")
test_content()
Logger.warn("[main] end testing")
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
