def run_test(self):
start_p2p_connection(self.nodes)
overall_generate_period_ms = 10
report_progress_blocks = 100
initial_chain_length = 20000
# Attacker computation power ratio in the total power
attacker_ratio = 0.4
attacker_generate_period_ms = overall_generate_period_ms / attacker_ratio
victim_generation_period_ms = overall_generate_period_ms / (
1 - attacker_ratio)
# attacker = self.nodes[0]
victim = self.nodes[0]
self.log.info(f"Generate initial {initial_chain_length} blocks")
last_block = victim.generate_empty_blocks(initial_chain_length)[-1]
last_height = parse_as_int(
RpcClient(victim).block_by_hash(last_block)["height"])
victim_handler = Victim("VICTIM",
victim,
victim_generation_period_ms,
self.log,
report_progress_blocks,
fixed_period=True)
victim_handler.start()
self.log.info("Victim started")
attacker_handler = Attacker("ATTACKER", victim,
attacker_generate_period_ms, self.log)
attacker_handler.set_fork_point(last_block, last_height)
attacker_handler.start()
self.log.info("Attacker started")
victim_handler.join()
def run_test(self):
start_p2p_connection(self.nodes)
n_generate_batch = 1000
n_attack_blocks = 15000
self.log.info(f"Attacker start to prepare {n_attack_blocks} blocks")
attack_blocks = create_chain_of_blocks(
parent_hash=self.nodes[0].p2p.genesis.hash,
parent_height=0,
count=n_attack_blocks)
self.log.info("Honest node generate")
for _ in range(int(20000 / n_generate_batch)):
batch_generate(self.nodes[0], n_generate_batch, self.log)
cnt = self.nodes[0].getblockcount()
self.log.info("Honest node block count: " + str(cnt))
for b in attack_blocks:
self.nodes[0].p2p.send_protocol_msg(NewBlock(b))
honest_cnt = 20000 + 1
for _ in range(1000):
batch_generate(self.nodes[0], n_generate_batch, self.log)
honest_cnt += n_generate_batch
cnt = self.nodes[0].getblockcount()
self.log.info("Honest node block count: " + str(cnt) + " " +
str(honest_cnt))
if honest_cnt + n_attack_blocks == cnt:
self.log.info("All attack blocks are processed!")
break
def _test_addlatency(self):
def on_block_headers(node, _):
msec = (datetime.datetime.now() - node.start_time).total_seconds() * 1000
self.log.info("Message arrived after " + str(msec) + "ms")
# The EventLoop in rust may have a deviation of a maximum of
# 100ms. This is because the ticker is 100ms by default.
assert msec >= node.latency_ms - 100
self.log.info("Test addlatency")
default_node = start_p2p_connection([self.nodes[0]])[0]
latency_ms = 1000
self.nodes[0].addlatency(default_node.key, latency_ms)
default_node.start_time = datetime.datetime.now()
default_node.latency_ms = latency_ms
handler = WaitHandler(default_node, GET_BLOCK_HEADERS_RESPONSE, on_block_headers)
self.nodes[0].p2p.send_protocol_msg(GetBlockHeaders(hashes=[default_node.genesis.block_header.hash]))
handler.wait()