def test_load_bitfield_and_ots_key_reuse(self):
with set_qrl_dir('no_data'):
state = State()
alice_xmss = get_alice_xmss(4)
paginated_bitfield = PaginatedBitfield(True, state._db)
self.assertFalse(paginated_bitfield.load_bitfield_and_ots_key_reuse(alice_xmss.address,
0))
addresses_state = {
alice_xmss.address: OptimizedAddressState.get_default(alice_xmss.address)
}
paginated_bitfield.set_ots_key(addresses_state, alice_xmss.address, 0)
self.assertTrue(paginated_bitfield.load_bitfield_and_ots_key_reuse(alice_xmss.address,
0))
def test_get_block_datapoint(self):
with set_data_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
blocks = gen_blocks(20, state, alice_xmss.address)
for i in range(1, 20):
datapoint = state.get_block_datapoint(blocks[i].headerhash)
self.assertEqual(datapoint.difficulty, "0")
self.assertEqual(datapoint.timestamp, 1615270948)
self.assertEqual(datapoint.header_hash,
blocks[i].headerhash)
self.assertEqual(datapoint.header_hash_prev,
blocks[i - 1].headerhash)
def test_create(self):
with set_wallet_dir("test_wallet"):
with State() as state:
self.assertIsNotNone(state)
chain = Chain(state)
self.assertIsNotNone(chain)
self.assertEqual(chain.staking_address,
b'Q1d6222fe3e53fafe8ce33acd2f8385c6dc044ab55452f0ebceb4d00233935ffaa72dd826')
self.assertEqual(chain.wallet.address_bundle[0].address,
b'Q1d6222fe3e53fafe8ce33acd2f8385c6dc044ab55452f0ebceb4d00233935ffaa72dd826')
def setUp(self):
with set_qrl_dir('no_data'):
self.state = State()
self.alice = get_alice_xmss()
self.params = {
"message_hash": b'Test Message',
"addr_to": None,
"fee": 1,
"xmss_pk": self.alice.pk
}
self.m_addr_state = Mock(autospec=OptimizedAddressState, name='addr_state', balance=200)
self.m_addr_from_pk_state = Mock(autospec=OptimizedAddressState, name='addr_from_pk_state')
def test_remove_token_metadata(self):
with set_qrl_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
bob_xmss = get_bob_xmss()
token_tx = get_token_transaction(alice_xmss, bob_xmss)
state.create_token_metadata(token_tx)
token_metadata = state.get_token_metadata(token_tx.txhash)
self.assertEqual(token_metadata.token_txhash, token_tx.txhash)
state.remove_token_metadata(token_tx)
self.assertIsNone(state.get_token_metadata(token_tx.txhash))
def test_write_batch(self):
with set_qrl_dir('no_data'):
with State() as state:
batch = state.get_batch()
block = Block.create(block_number=10,
prevblock_headerhash=b'aa',
transactions=[],
miner_address=b'aa')
state.put_block(block, batch)
self.assertIsNone(state.get_block(block.headerhash))
state.write_batch(batch)
block2 = state.get_block(block.headerhash)
self.assertEqual(block.headerhash, block2.headerhash)
def test_state_mainchain(self):
with set_data_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
blocks = gen_blocks(20, state, alice_xmss.address)
address_set = state.prepare_address_list(blocks[-1])
m = state.get_state_mainchain(address_set)
state.update_mainchain_state(m, 20, blocks[-1].headerhash)
self.assertIsNotNone(m)
self.assertTrue(len(m) > 0)
state.update_mainchain_height(5, None)
self.assertEqual(state.get_mainchain_height(), 5)
self.assertIsNotNone(state.get_ephemeral_metadata(b"0"))
def test_get_token_metadata(self):
with set_qrl_dir('no_data'):
with State() as state:
token_txhash = bytes(sha2_256(b'alpha'))
token_metadata = TokenMetadata.create(
token_txhash,
[bytes(sha2_256(b'delta')),
bytes(sha2_256(b'gamma'))])
state._db.get_raw = MagicMock(
return_value=token_metadata.to_json())
self.assertEqual(
state.get_token_metadata(token_txhash).to_json(),
token_metadata.to_json())
def test_address_state(self):
with set_data_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
blocks = gen_blocks(20, state, alice_xmss.address)
for i, block in enumerate(blocks):
self.assertIn(alice_xmss.address, state.prepare_address_list(block))
address_state = state.get_state(block.headerhash, state.prepare_address_list(block))
self.assertIn(alice_xmss.address, address_state.keys())
self.assertEqual(address_state[config.dev.coinbase_address].nonce, i + 1)
with self.assertRaises(Exception):
state.set_addresses_state({"state": 'test'}, 0)
def setUp(self):
with set_qrl_dir('no_data'):
self.state = State()
self.chain_manager = ChainManager(self.state)
self.alice = get_alice_xmss()
self.bob = get_bob_xmss()
self.slave = get_slave_xmss()
self.tx1 = TransferTransaction.create(addrs_to=[self.bob.address], amounts=[10],
message_data=None, fee=1, xmss_pk=self.alice.pk)
self.tx2 = TransferTransaction.create(addrs_to=[self.bob.address], amounts=[10],
message_data=None, fee=1, xmss_pk=self.slave.pk,
master_addr=self.alice.address)
self.tx1._data.nonce = 3
self.tx2._data.nonce = 6
self.tx1.sign(self.alice)
self.tx2.sign(self.slave)
self.block_attrs = {
"dev_config": config.dev,
"block_number": 5,
"prev_headerhash": bytes(sha2_256(b'test')),
"prev_timestamp": 10,
"transactions": [self.tx1, self.tx2],
"miner_address": self.alice.address,
"seed_height": 0,
"seed_hash": None,
}
self.coinbase_addrstate_attrs = OptimizedAddressState.get_default(config.dev.coinbase_address)
self.coinbase_addrstate_attrs.update_balance(None,
int(config.dev.coin_remaining_at_genesis * config.dev.shor_per_quanta))
self.bob_addrstate_attrs = OptimizedAddressState.get_default(self.bob.address)
self.bob_addrstate_attrs.update_balance(None, 20)
self.alice_addrstate_attrs = OptimizedAddressState.get_default(self.alice.address)
self.alice_addrstate_attrs.update_balance(None, 100)
self.alice_addrstate_attrs.pbdata.nonce = 2
self.slave_addrstate_attrs = OptimizedAddressState.get_default(self.slave.address)
self.slave_addrstate_attrs.pbdata.nonce = 5
def test_getBlockByNumber(self):
with set_qrl_dir('no_data'):
db_state = State()
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
alice_xmss = get_alice_xmss()
b = Block.create(dev_config=config.dev,
block_number=1,
prev_headerhash=sha256(b'reveal'),
prev_timestamp=10,
transactions=[],
miner_address=alice_xmss.address,
seed_height=0,
seed_hash=None)
Block.put_block(db_state, b, None)
Block.put_block_number_mapping(db_state,
b.block_number,
qrl_pb2.BlockNumberMapping(headerhash=b.headerhash),
None)
db_state.get_block_by_number = MagicMock(return_value=b)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetBlockByNumberReq(block_number=b.block_number)
response = service.GetBlockByNumber(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(1, response.block.header.block_number)
def test_addr_tx_hashes(self):
with set_data_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
alice_address = bytes(alice_xmss.get_address().encode()) # FIXME: This needs to be refactored
some_hash1 = bin2hstr(sha256(b'some_hash1')).encode()
some_hash2 = bin2hstr(sha256(b'some_hash2')).encode()
state.update_address_tx_hashes(alice_address, some_hash1)
state.update_address_tx_hashes(alice_address, some_hash2)
result = state.get_address_tx_hashes(alice_address)
self.assertEqual(some_hash1, result[0])
self.assertEqual(some_hash2, result[1])
def test_set_block_pos(self):
with State() as state:
block_number = 123
block_position = 234
block_size = 345
state._db.put('block_{}'.format(block_number), [block_position, block_size])
pos_size = state._db.get('block_{}'.format(block_number))
read_position, read_size = pos_size
self.assertEqual(block_position, read_position)
self.assertEqual(block_size, read_size)
def test_block_metadata(self):
with set_data_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
blocks = gen_blocks(20, state, alice_xmss.address)
for block in blocks:
state.put_block_metadata(block.headerhash, BlockMetadata(),
None)
for block in blocks:
self.assertEqual(
state.get_block_metadata(block.headerhash).to_json(),
b'{}')
def test_update_tx_metadata(self):
with set_qrl_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
tx = TransferTransaction.create(addrs_to=[get_some_address(1), get_some_address(2)],
amounts=[1, 2],
fee=0,
xmss_pk=alice_xmss.pk)
block_number = 5
state.put_tx_metadata(tx, block_number, 10000, None)
tx_metadata = state.get_tx_metadata(tx.txhash)
self.assertEqual(tx_metadata[0].to_json(), tx.to_json())
self.assertEqual(tx_metadata[1], block_number)
def __init__(self, *args, **kwargs):
super(TestMultiSigSpend, self).__init__(*args, **kwargs)
with set_qrl_dir('no_data'):
self.state = State()
self.alice = get_alice_xmss()
self.bob = get_bob_xmss()
self.random = get_alice_xmss(4)
self.random_signer = get_bob_xmss(4)
self.signatories = [
self.alice.address, self.bob.address, self.random.address
]
self.weights = [20, 30, 10]
self.threshold = 30
def test_get_block_datapoint(self):
with set_qrl_dir('no_data'):
with State() as state:
# Test Case: When block not found
self.assertIsNone(state.get_block_datapoint(b'test'))
alice_xmss = get_alice_xmss()
blocks = gen_blocks(20, state, alice_xmss.address)
for i in range(1, 20):
datapoint = state.get_block_datapoint(blocks[i].headerhash)
self.assertEqual(datapoint.difficulty, "256")
self.assertEqual(datapoint.timestamp, 1615270947 + i)
self.assertEqual(datapoint.header_hash, blocks[i].headerhash)
self.assertEqual(datapoint.header_hash_prev, blocks[i - 1].headerhash)
def test_get_address2(self):
with set_qrl_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
alice_address = alice_xmss.address
address_state = state.get_address_state(alice_address)
addresses_state = {
alice_address: address_state
}
self.assertTrue(isinstance(address_state.address, bytes))
state.put_addresses_state(addresses_state)
address_state = state.get_address_state(alice_address)
self.assertTrue(isinstance(address_state.address, bytes))
def test_put_addresses_state(self):
with set_qrl_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
alice_state = AddressState.get_default(alice_xmss.address)
addresses_state = {
alice_state.address: alice_state,
b'test1': AddressState.get_default(b'test1')
}
state.put_addresses_state(addresses_state, None)
alice_state2 = state.get_address_state(alice_xmss.address)
self.assertEqual(alice_state.serialize(), alice_state2.serialize())
test_state = state.get_address_state(b'test1')
self.assertEqual(test_state.serialize(), AddressState.get_default(b'test1').serialize())
def test_remove(self, mock_dev_config):
with set_qrl_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
key = b'test_key'
value = [b'hello world']
storage_key = p.generate_key(key, 11)
p.put(storage_key, value, None)
found_value = p.get_paginated_data(key, 11)
self.assertEqual(value, found_value)
p.delete(storage_key, None)
found_value = p.get_paginated_data(key, 11)
self.assertEqual([], found_value)
def validate_mining_nonce(self,
state: State,
blockheader: BlockHeader,
enable_logging=False):
parent_metadata = state.get_block_metadata(
blockheader.prev_blockheaderhash)
parent_block = state.get_block(blockheader.prev_blockheaderhash)
measurement = state.get_measurement(blockheader.timestamp,
blockheader.prev_blockheaderhash,
parent_metadata)
diff, target = DifficultyTracker.get(
measurement=measurement,
parent_difficulty=parent_metadata.block_difficulty)
if enable_logging:
logger.debug('-----------------START--------------------')
logger.debug('Validate #%s', blockheader.block_number)
logger.debug('block.timestamp %s', blockheader.timestamp)
logger.debug('parent_block.timestamp %s', parent_block.timestamp)
logger.debug('parent_block.difficulty %s',
UInt256ToString(parent_metadata.block_difficulty))
logger.debug('diff : %s | target : %s', UInt256ToString(diff),
target)
logger.debug('-------------------END--------------------')
if not self.verify_input_cached(blockheader.mining_blob, target):
if enable_logging:
logger.warning("PoW verification failed")
qn = Qryptonight()
tmp_hash = qn.hash(blockheader.mining_blob)
logger.warning("{}".format(tmp_hash))
logger.debug('%s', blockheader.to_json())
return False
return True
def test_check_mock(self):
with set_qrl_dir('no_data'):
with State() as state:
self.assertIsNotNone(
state) # to avoid warning (unused variable)
state.get_block = Mock()
state.get_block.side_effect = self.get_block_list_example1()
block = state.get_block(b'0')
self.assertEqual(10, block.timestamp)
self.assertEqual(0, block.block_number)
self.assertEqual(b'0', block.headerhash)
def test_measurement_1(self):
with set_qrl_dir('no_data'):
with State() as state:
self.assertIsNotNone(
state) # to avoid warning (unused variable)
state.get_block = Mock(
side_effect=TestStateMeasurement.get_block_example1)
parent_metadata = Mock()
parent_metadata.last_N_headerhashes = [b'0']
measurement = state.get_measurement(210, b'1', parent_metadata)
self.assertEqual(55, measurement)
measurement = state.get_measurement(250, b'1', parent_metadata)
self.assertEqual(75, measurement)
def test_create_token_metadata(self):
with set_qrl_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
bob_xmss = get_bob_xmss()
token_transaction = get_token_transaction(alice_xmss, bob_xmss)
state.create_token_metadata(token_transaction)
token_metadata = state.get_token_metadata(
token_transaction.txhash)
self.assertEqual(token_metadata.token_txhash,
token_transaction.txhash)
self.assertEqual(token_metadata.transfer_token_tx_hashes[0],
token_transaction.txhash)
def test_add_many_and_save(self):
with set_wallet_dir("test_wallet"):
with State() as state:
self.assertIsNotNone(state)
chain = Chain(state)
alice_xmss = get_alice_xmss()
staking_address = bytes(alice_xmss.get_address().encode())
with patch('qrl.core.config.dev.disk_writes_after_x_blocks'):
qrl.core.config.dev.disk_writes_after_x_blocks = 4
prev = bytes()
address_state_dict = dict()
address_state_dict[staking_address] = AddressState.create(
address=staking_address,
nonce=0,
balance=100,
pubhashes=[])
for i in range(10):
tmp_block1 = Block.create(
staking_address=staking_address,
block_number=i,
reveal_hash=bytes(),
prevblock_headerhash=prev,
transactions=[],
duplicate_transactions=OrderedDict(),
vote=VoteMetadata(),
signing_xmss=alice_xmss,
nonce=address_state_dict[staking_address].nonce +
1)
prev = tmp_block1.headerhash
res = chain.add_block(tmp_block1, address_state_dict,
StakeValidatorsTracker(),
b'1001', alice_xmss)
address_state_dict[staking_address].increase_nonce()
address_state_dict[
staking_address].balance += tmp_block1.block_reward
self.assertEqual(
i, chain.height
) # FIXME: wrong name, it is not height but max_index
self.assertTrue(res)
print(qrl.core.config.dev.disk_writes_after_x_blocks)
def test_put_tx_metadata(self):
with set_qrl_dir('no_data'):
with State() as state:
self.assertIsNone(state.get_tx_metadata(b'test1'))
alice_xmss = get_alice_xmss()
tx = TransferTransaction.create(addrs_to=[b'q1', b'q2'],
amounts=[1, 2],
fee=0,
xmss_pk=alice_xmss.pk)
block_number = 5
state.put_tx_metadata(tx, block_number, 10000, None)
tx_metadata = state.get_tx_metadata(tx.txhash)
self.assertEqual(tx_metadata[0].to_json(), tx.to_json())
self.assertEqual(tx_metadata[1], block_number)
def test_last_block(self):
with set_qrl_dir('no_data'):
def get_block_by_number(block_number):
block = Block()
block.blockheader._data.block_number = block_number
return block
with State() as state:
self.assertIsNone(state.last_block)
state.get_block_by_number = MagicMock(side_effect=get_block_by_number)
state.update_mainchain_height(10, None)
self.assertEqual(state.last_block.block_number, 10)
state.update_mainchain_height(1, None)
self.assertEqual(state.last_block.block_number, 1)
def main():
args = parse_arguments()
config.create_path(config.user.wallet_dir)
mining_credit_wallet = get_mining_credit_wallet(args.mining_credit_wallet)
if not mining_credit_wallet:
logger.warning('Invalid Mining Credit Wallet Address')
logger.warning('%s', args.mining_credit_wallet)
return False
logger.debug(
"====================================================================================="
)
logger.info("Data Path: %s", args.data_dir)
config.user.data_dir = args.data_dir
config.create_path(config.user.data_dir)
ntp.setDrift()
logger.info('Initializing chain..')
persistent_state = State()
chain_manager = ChainManager(state=persistent_state)
chain_manager.load(Block.from_json(GenesisBlock().to_json()))
qrlnode = QRLNode(db_state=persistent_state,
mining_credit_wallet=mining_credit_wallet)
qrlnode.set_chain_manager(chain_manager)
set_logger(args, qrlnode.sync_state)
#######
# NOTE: Keep assigned to a variable or might get collected
admin_service, grpc_service, mining_service = start_services(qrlnode)
qrlnode.start_listening()
qrlnode.connect_peers()
qrlnode.start_pow(args.mining_thread_count)
logger.info('QRL blockchain ledger %s', config.dev.version)
logger.info('mining/staking address %s', args.mining_credit_wallet)
# FIXME: This will be removed once we move away from Twisted
reactor.run()
def test_put_block_metadata(self):
with set_qrl_dir('no_data'):
with State() as state:
block_metadata = BlockMetadata.create()
block_metadata.update_last_headerhashes([b'test1', b'test2'], b'test3')
state.put_block_metadata(b'block_headerhash', block_metadata, None)
state.put_block_metadata(b'block_headerhash2', BlockMetadata.create(), None)
self.assertEqual(state.get_block_metadata(b'block_headerhash').to_json(),
block_metadata.to_json())
expected_json = b'{\n "blockDifficulty": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",\n ' \
b'"cumulativeDifficulty": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="\n}'
self.assertEqual(state.get_block_metadata(b'block_headerhash2').to_json(),
expected_json)
def test_add_genesis(self):
with State() as state:
with set_wallet_dir("test_wallet"):
chain = Mock(spec=Chain)
chain.height = 0
chain.get_block = MagicMock(return_value=None)
chain.wallet = Wallet()
chain.pstate = state
buffered_chain = BufferedChain(chain)
b0 = buffered_chain.get_block(0)
buffered_chain._chain.get_block.assert_called()
self.assertIsNone(b0)
res = buffered_chain.add_block(block=GenesisBlock())
self.assertTrue(res)
