def process_header(self, header, block_origin):
hash_ = header.GetHash()
logging.info('process Block(hash={}) from {}'.format(core.b2lx(hash_), block_origin))
fork_before = chainutil.get_private_public_fork(self.tips)
logging.info('fork before {}'.format(fork_before))
self.try_to_insert_header(header, block_origin)
fork_after = chainutil.get_private_public_fork(self.tips)
logging.info('fork after {}'.format(fork_after))
if self.initializing:
if hash_ == self.start_hash or header.hashPrevBlock == self.start_hash:
self.initializing = False
logging.info('Initializing over; now starting selfish mining')
else:
logging.info('chain is initializing - no action needs to be taken')
else:
if fork_before != fork_after:
logging.debug('fork tip_private={}'.format(core.b2lx(fork_after.private_tip.hash())))
logging.debug('fork tip_public={}'.format(core.b2lx(fork_after.public_tip.hash())))
try:
action = self.strategy.find_action(fork_after.private_height, fork_after.public_height, block_origin)
logging.info('found action={}'.format(action))
self.executor.execute(action, fork_after.private_tip, fork_after.public_tip)
except ActionException as exception:
logging.warn(exception.message)
else:
logging.debug('the two forks are the same - no action needs to be taken')
def test_get_private_public_fork_no_public_tip(self):
fork = chainutil.get_private_public_fork([self.second_block_chain_a])
self.assertEqual(fork.public_height, 0)
self.assertEqual(fork.public_tip.hash(), test_util.genesis_hash)
self.assertEqual(fork.private_height, 2)
self.assertEqual(fork.private_tip.hash(), '2a')
def test_get_private_public_fork_lead_public(self):
fork = chainutil.get_private_public_fork(
[self.second_block_chain_b, self.first_block_chain_a])
self.assertEqual(fork.private_height, 1)
self.assertEqual(fork.private_tip.hash(), '1a')
self.assertEqual(fork.public_height, 2)
self.assertEqual(fork.public_tip.hash(), '2b')
def test_get_private_public_fork_one_private_transferred(self):
self.first_block_chain_a.transfer_allowed = True
fork = chainutil.get_private_public_fork(
[self.second_block_chain_a, self.first_block_chain_b])
self.assertEqual(fork.private_height, 2)
self.assertEqual(fork.private_tip.hash(), '2a')
self.assertEqual(fork.public_height, 1)
def test_get_private_public_fork_public_fork_point(self):
fork = chainutil.get_private_public_fork([
self.fourth_block_chain_b, self.third_b_block_chain_b,
self.second_block_chain_a
])
self.assertEqual(fork.private_height, 2)
self.assertEqual(fork.private_tip.hash(), '2a')
self.assertEqual(fork.public_height, 4)
self.assertEqual(fork.public_tip.hash(), '4b')
def test_get_private_public_fork_longest_private_fork_transferred(self):
self.first_block_chain_a.transfer_allowed = True
self.second_block_chain_a.transfer_allowed = True
self.third_a_block_chain_a.transfer_allowed = True
self.fourth_block_chain_a.transfer_allowed = True
fork = chainutil.get_private_public_fork([
self.second_block_chain_b, self.fourth_block_chain_a,
self.third_b_block_chain_a
])
self.assertEqual(fork.private_height, 0)
self.assertEqual(fork.private_tip.hash(), '4a')
self.assertEqual(fork.public_height, 0)
self.assertEqual(fork.public_tip.hash(), '4a')
