def create_block(self, prev_hash):
transactions = []
block_prev = self.qrlnode.get_block_from_hash(prev_hash)
block_idx = block_prev.block_number + 1
if block_idx == 1:
slave_tx = SlaveTransaction.create(slave_pks=[self.bob_xmss.pk],
access_types=[0],
fee=0,
xmss_pk=self.alice_xmss.pk)
slave_tx.sign(self.alice_xmss)
slave_tx._data.nonce = 1
transactions = [slave_tx]
self.time_mock.return_value = self.time_mock.return_value + 60
self.ntp_mock.return_value = self.ntp_mock.return_value + 60
block_new = Block.create(block_number=block_idx,
prevblock_headerhash=block_prev.headerhash,
transactions=transactions,
miner_address=self.alice_xmss.address)
while not PoWValidator().validate_mining_nonce(state=self.qrlnode._chain_manager.state,
blockheader=block_new.blockheader,
enable_logging=False):
block_new.set_mining_nonce(block_new.mining_nonce + 1)
return block_new
def qrlnode_with_mock_blockchain(num_blocks):
start_time = time.time()
with mock.patch('qrl.core.misc.ntp.getTime') as ntp_mock, \
set_data_dir('no_data'), \
State() as state, \
mock.patch('time.time') as time_mock: # noqa
time_mock.return_value = start_time
ntp_mock.return_value = start_time
state.get_measurement = MagicMock(return_value=10000000)
required_height = ceil(log(num_blocks, 2))
required_height = int(required_height + required_height % 2)
alice_xmss = get_alice_xmss(xmss_height=required_height)
bob_xmss = get_bob_xmss()
genesis_block = GenesisBlock()
chain_manager = ChainManager(state)
chain_manager.load(genesis_block)
chain_manager._difficulty_tracker = Mock()
dt = DifficultyTracker()
tmp_difficulty = StringToUInt256('2')
tmp_target = dt.get_target(tmp_difficulty)
chain_manager._difficulty_tracker.get = MagicMock(return_value=(tmp_difficulty, tmp_target))
block_prev = state.get_block(genesis_block.headerhash)
for block_idx in range(1, num_blocks):
transactions = []
if block_idx == 1:
slave_tx = SlaveTransaction.create(slave_pks=[bob_xmss.pk],
access_types=[0],
fee=0,
xmss_pk=alice_xmss.pk)
slave_tx.sign(alice_xmss)
slave_tx._data.nonce = 2
transactions = [slave_tx]
time_mock.return_value = time_mock.return_value + 60
ntp_mock.return_value = ntp_mock.return_value + 60
block_new = Block.create(block_number=block_idx,
prevblock_headerhash=block_prev.headerhash,
transactions=transactions,
miner_address=alice_xmss.address)
while not PoWValidator().validate_mining_nonce(state, block_new.blockheader, False):
block_new.set_nonces(block_new.mining_nonce + 1, 0)
chain_manager.add_block(block_new)
block_prev = block_new
qrlnode = QRLNode(state, mining_credit_wallet=alice_xmss.address)
qrlnode.set_chain_manager(chain_manager)
yield qrlnode
def create_slave_tx(self, slave_pks: list, access_types: list, fee: int,
xmss_pk: bytes,
master_addr: bytes) -> SlaveTransaction:
return SlaveTransaction.create(slave_pks=slave_pks,
access_types=access_types,
fee=fee,
xmss_pk=xmss_pk,
master_addr=master_addr)
def create_slave_tx(self, addr_from: bytes, slave_pks: list,
access_types: list, fee: int,
xmss_pk: bytes) -> SlaveTransaction:
return SlaveTransaction.create(addr_from=addr_from,
slave_pks=slave_pks,
access_types=access_types,
fee=fee,
xmss_pk=xmss_pk)
def create_slave_tx(self,
addr_from: bytes,
slave_pks: list,
access_types: list,
fee: int,
xmss_pk: bytes,
xmss_ots_index: int) -> SlaveTransaction:
return SlaveTransaction.create(addr_from=addr_from,
slave_pks=slave_pks,
access_types=access_types,
fee=fee,
xmss_pk=xmss_pk,
xmss_ots_index=xmss_ots_index)
def get_slaves(alice_ots_index, txn_nonce):
# [master_address: bytes, slave_seeds: list, slave_txn: json]
slave_xmss = get_slave_xmss()
alice_xmss = get_alice_xmss()
alice_xmss.set_ots_index(alice_ots_index)
slave_txn = SlaveTransaction.create([slave_xmss.pk],
[1],
0,
alice_xmss.pk)
slave_txn._data.nonce = txn_nonce
slave_txn.sign(alice_xmss)
slave_data = json.loads(json.dumps([bin2hstr(alice_xmss.address), [slave_xmss.extended_seed], slave_txn.to_json()]))
slave_data[0] = bytes(hstr2bin(slave_data[0]))
return slave_data
def test_bad_tx(self):
source = Mock()
source.factory = Mock()
source.factory.master_mr = Mock()
source.factory.master_mr.isRequested = Mock()
source.factory.add_unprocessed_txn = Mock()
channel = Observable(source)
self.tx_manager = P2PTxManagement()
self.tx_manager.new_channel(channel)
tx = SlaveTransaction.create([], [], 1, bytes(100))
event = qrllegacy_pb2.LegacyMessage(func_name=qrllegacy_pb2.LegacyMessage.TX,
txData=tx.pbdata)
channel.notify(event, force_delivery=True)
source.factory.master_mr.isRequested.assert_not_called()
source.factory.add_unprocessed_txn.assert_not_called()
def test_add_block(self, mock_difficulty_tracker_get):
"""
Testing add_block, with fork logic
:return:
"""
with set_data_dir('no_data'):
with State() as state:
state.get_measurement = MagicMock(return_value=10000000)
alice_xmss = get_alice_xmss()
bob_xmss = get_bob_xmss()
genesis_block = GenesisBlock()
chain_manager = ChainManager(state)
mock_difficulty_tracker_get.return_value = [
config.dev.mining_setpoint_blocktime, 2
]
chain_manager.load(genesis_block)
chain_manager._difficulty_tracker = Mock()
tmp_difficulty = StringToUInt256('2')
tmp_target = DifficultyTracker.get_target(tmp_difficulty)
mock_difficulty_tracker_get.return_value = [
tmp_difficulty, tmp_target
]
block = state.get_block(genesis_block.headerhash)
self.assertIsNotNone(block)
slave_tx = SlaveTransaction.create(slave_pks=[bob_xmss.pk],
access_types=[0],
fee=0,
xmss_pk=alice_xmss.pk)
slave_tx.sign(alice_xmss)
slave_tx._data.nonce = 1
self.assertTrue(slave_tx.validate())
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1615270948 # Very high to get an easy difficulty
block_1 = Block.create(
block_number=1,
prevblock_headerhash=genesis_block.headerhash,
transactions=[slave_tx],
miner_address=alice_xmss.address)
block_1.set_nonces(274, 0)
# Uncomment only to determine the correct mining_nonce of above blocks
# from qrl.core.PoWValidator import PoWValidator
# while not PoWValidator().validate_mining_nonce(state, block_1.blockheader, False):
# block_1.set_mining_nonce(block_1.mining_nonce + 1)
# print(block_1.mining_nonce)
result = chain_manager.add_block(block_1)
self.assertTrue(result)
self.assertEqual(chain_manager.last_block, block_1)
alice_state = chain_manager.get_address(alice_xmss.address)
self.assertEqual(len(alice_state.slave_pks_access_type), 1)
self.assertTrue(
str(bob_xmss.pk) in alice_state.slave_pks_access_type)
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1715270948 # Very high to get an easy difficulty
block = Block.create(
block_number=1,
prevblock_headerhash=genesis_block.headerhash,
transactions=[],
miner_address=bob_xmss.address)
block.set_nonces(2, 0)
# Uncomment only to determine the correct mining_nonce of above blocks
# from qrl.core.PoWValidator import PoWValidator
# while not PoWValidator().validate_mining_nonce(state, block.blockheader, False):
# block.set_nonces(block.mining_nonce + 1)
# print(block.mining_nonce)
result = chain_manager.add_block(block)
self.assertTrue(result)
self.assertEqual(chain_manager.last_block, block_1)
block = state.get_block(block.headerhash)
self.assertIsNotNone(block)
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1815270948 # Very high to get an easy difficulty
block_2 = Block.create(
block_number=2,
prevblock_headerhash=block.headerhash,
transactions=[],
miner_address=bob_xmss.address)
block_2.set_nonces(0, 0)
# Uncomment only to determine the correct mining_nonce of above blocks
# from qrl.core.PoWValidator import PoWValidator
# while not PoWValidator().validate_mining_nonce(state, block_2.blockheader, False):
# block_2.set_mining_nonce(block_2.mining_nonce + 1)
# print(block_2.mining_nonce)
result = chain_manager.add_block(block_2)
self.assertTrue(result)
self.assertEqual(chain_manager.last_block.block_number,
block_2.block_number)
self.assertEqual(chain_manager.last_block.to_json(),
block_2.to_json())
def test_add_block(self):
"""
Testing add_block, with fork logic
:return:
"""
with set_data_dir('no_data'):
with State() as state:
state.get_measurement = MagicMock(return_value=10000000)
alice_xmss = get_alice_xmss()
bob_xmss = get_bob_xmss()
genesis_block = GenesisBlock()
chain_manager = ChainManager(state)
chain_manager.load(genesis_block)
chain_manager._difficulty_tracker = Mock()
dt = DifficultyTracker()
tmp_difficulty = StringToUInt256('2')
tmp_boundary = dt.get_boundary(tmp_difficulty)
chain_manager._difficulty_tracker.get = MagicMock(return_value=(tmp_difficulty, tmp_boundary))
block = state.get_block(genesis_block.headerhash)
self.assertIsNotNone(block)
slave_tx = SlaveTransaction.create(addr_from=alice_xmss.get_address(),
slave_pks=[bob_xmss.pk()],
access_types=[0],
fee=0,
xmss_pk=alice_xmss.pk(),
xmss_ots_index=alice_xmss.get_index())
slave_tx.sign(alice_xmss)
slave_tx._data.nonce = 2
self.assertTrue(slave_tx.validate())
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1615270948 # Very high to get an easy difficulty
block_1 = Block.create(mining_nonce=10,
block_number=1,
prevblock_headerhash=genesis_block.headerhash,
transactions=[slave_tx],
signing_xmss=alice_xmss,
master_address=alice_xmss.get_address(),
nonce=1)
while not chain_manager.validate_mining_nonce(block_1, False):
block_1.set_mining_nonce(block_1.mining_nonce + 1)
result = chain_manager.add_block(block_1)
self.assertTrue(result)
self.assertEqual(chain_manager.last_block, block_1)
alice_state = chain_manager.get_address(alice_xmss.get_address())
self.assertEqual(len(alice_state.slave_pks_access_type), 1)
self.assertTrue(str(bob_xmss.pk()) in alice_state.slave_pks_access_type)
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1715270948 # Very high to get an easy difficulty
block = Block.create(mining_nonce=15,
block_number=1,
prevblock_headerhash=genesis_block.headerhash,
transactions=[],
signing_xmss=bob_xmss,
master_address=bob_xmss.get_address(),
nonce=1)
while not chain_manager.validate_mining_nonce(block, False):
block.set_mining_nonce(block.mining_nonce + 1)
result = chain_manager.add_block(block)
self.assertTrue(result)
self.assertEqual(chain_manager.last_block, block_1)
block = state.get_block(block.headerhash)
self.assertIsNotNone(block)
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1815270948 # Very high to get an easy difficulty
block_2 = Block.create(mining_nonce=15,
block_number=2,
prevblock_headerhash=block.headerhash,
transactions=[],
signing_xmss=bob_xmss,
master_address=bob_xmss.get_address(),
nonce=2)
while not chain_manager.validate_mining_nonce(block_2, False):
block_2.set_mining_nonce(block_2.mining_nonce + 1)
result = chain_manager.add_block(block_2)
self.assertTrue(result)
self.assertEqual(chain_manager.last_block.block_number, block_2.block_number)
self.assertEqual(chain_manager.last_block.to_json(), block_2.to_json())
