def test_measurement_0(self, mock_get_block):
with set_qrl_dir('no_data'):
with State() as state:
self.assertIsNotNone(
state) # to avoid warning (unused variable)
chain_manager = ChainManager(state)
mock_get_block.side_effect = TestStateMeasurement.get_block_example1
parent_metadata = Mock()
parent_metadata.last_N_headerhashes = []
measurement = chain_manager.get_measurement(
config.dev,
100,
parent_headerhash=b'0',
parent_metadata=parent_metadata)
self.assertEqual(60, measurement)
measurement = chain_manager.get_measurement(
config.dev,
110,
parent_headerhash=b'0',
parent_metadata=parent_metadata)
self.assertEqual(60, measurement)
measurement = chain_manager.get_measurement(
config.dev,
1000,
parent_headerhash=b'0',
parent_metadata=parent_metadata)
self.assertEqual(60, measurement)
def create(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)
genesis_difficulty = config.dev.genesis_difficulty
try:
config.dev.genesis_difficulty = 10
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))
qrlnode = QRLNode(state, mining_credit_wallet=b'')
qrlnode.set_chain_manager(chain_manager)
mock_blockchain = MockedBlockchain(qrlnode, time_mock, ntp_mock, )
for block_idx in range(1, num_blocks + 1):
mock_blockchain.add_new_block()
yield mock_blockchain
finally:
config.dev.genesis_difficulty = genesis_difficulty
def test_getHeight(self):
db_state = Mock(spec=State)
alice_xmss = get_alice_xmss()
address_state = AddressState.create(address=alice_xmss.address,
nonce=25,
balance=10,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
db_state.get_address_state = MagicMock(return_value=address_state)
p2p_factory = Mock(spec=P2PFactory)
chain_manager = ChainManager(db_state)
chain_manager._last_block = Mock()
chain_manager._last_block.block_number = 100
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetHeightReq()
response = service.GetHeight(request=request, context=context)
self.assertEqual(response.height, 100)
def test_getHeight(self):
with set_qrl_dir('no_data'):
db_state = State()
alice_xmss = get_alice_xmss()
optimized_address_state = OptimizedAddressState.create(address=alice_xmss.address,
nonce=25,
balance=10,
ots_bitfield_used_page=0,
transaction_hash_count=0,
tokens_count=0,
lattice_pk_count=0,
slaves_count=0,
multi_sig_address_count=0)
addresses_state = {optimized_address_state.address: optimized_address_state}
AddressState.put_addresses_state(db_state, addresses_state)
p2p_factory = Mock(spec=P2PFactory)
chain_manager = ChainManager(db_state)
chain_manager._last_block = Mock()
chain_manager._last_block.block_number = 100
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetHeightReq()
response = service.GetHeight(request=request, context=context)
self.assertEqual(response.height, 100)
def test_load(self):
with set_data_dir('no_data'):
with State() as state:
genesis_block = GenesisBlock()
chain_manager = ChainManager(state)
chain_manager.load(genesis_block)
block = state.get_block(GenesisBlock().headerhash)
self.assertIsNotNone(block)
def test_load(self):
with set_data_dir('no_data'):
with State() as state:
genesis_block = GenesisBlock()
chain_manager = ChainManager(state)
chain_manager.load(genesis_block)
block = state.get_block(GenesisBlock().headerhash)
self.assertIsNotNone(block)
def main():
args = parse_arguments()
logger.debug(
"====================================================================================="
)
logger.info("QRL Path: %s", args.qrl_dir)
config.user.qrl_dir = expanduser(args.qrl_dir)
config.create_path(config.user.qrl_dir)
logger.debug(
"====================================================================================="
)
config.create_path(config.user.wallet_dir)
mining_address = None
if config.user.mining_enabled:
mining_address = get_mining_address(args.mining_address)
if not mining_address:
logger.warning('Invalid Mining Credit Wallet Address')
logger.warning('%s', args.mining_address)
return False
ntp.setDrift()
if args.debug:
logger.warning("FAULT HANDLER ENABLED")
faulthandler.enable()
logger.info('Initializing chain..')
persistent_state = State()
if args.measurement > -1:
persistent_state.get_measurement = MagicMock(
return_value=args.measurement)
chain_manager = ChainManager(state=persistent_state)
chain_manager.load(Block.from_json(GenesisBlock().to_json()))
qrlnode = QRLNode(db_state=persistent_state, mining_address=mining_address)
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_address)
# FIXME: This will be removed once we move away from Twisted
reactor.run()
def test_check_stale_txn(self, m_is_full_transaction_pool, m_config):
"""
Stale Transactions are Transactions that were supposed to go into block 5, but for some reason didn't make it.
They languish in TransactionPool until check_stale_txn() checks the Pool and updates the tx_info to make them
go into a higher block.
For each stale transaction, P2PFactory.broadcast_tx() will be called.
"""
# Redefine at what point should txs be considered stale
m_config.user.stale_transaction_threshold = 2
bob_xmss = get_bob_xmss(4)
alice_xmss = get_alice_xmss(4)
tx1 = TransferTransaction.create(addrs_to=[bob_xmss.address],
amounts=[1000000],
message_data=None,
fee=1,
xmss_pk=alice_xmss.pk)
tx1.sign(alice_xmss)
tx2 = TransferTransaction.create(addrs_to=[bob_xmss.address],
amounts=[10000],
message_data=None,
fee=1,
xmss_pk=alice_xmss.pk)
tx2.sign(alice_xmss)
m_broadcast_tx = Mock(
name='Mock Broadcast TX function (in P2PFactory)')
self.txpool.add_tx_to_pool(tx1, 5)
self.txpool.add_tx_to_pool(tx2, 5)
self.txpool.set_broadcast_tx(m_broadcast_tx)
with set_qrl_dir('no_data'):
state = State()
chain_manager = ChainManager(state)
self.txpool.check_stale_txn(chain_manager.new_state_container,
chain_manager.update_state_container,
8)
self.assertEqual(m_broadcast_tx.call_count, 0)
m = MockFunction()
bob_address_state = OptimizedAddressState.get_default(
bob_xmss.address)
bob_address_state.pbdata.balance = 1000000000000
m.put(bob_xmss.address, bob_address_state)
chain_manager.get_optimized_address_state = m.get
tx3 = TransferTransaction.create(addrs_to=[alice_xmss.address],
amounts=[10000],
message_data=None,
fee=1,
xmss_pk=bob_xmss.pk)
tx3.sign(bob_xmss)
self.txpool.add_tx_to_pool(tx3, 5)
self.txpool.check_stale_txn(chain_manager.new_state_container,
chain_manager.update_state_container,
8)
self.assertEqual(m_broadcast_tx.call_count, 1)
def setUp(self):
with set_qrl_dir('no_data'):
self.state = State()
self.state.get_measurement = Mock(return_value=10000000)
del GenesisBlock.instance # Removing Singleton instance
self.genesis_block = GenesisBlock()
self.chain_manager = ChainManager(self.state)
self.chain_manager._difficulty_tracker = Mock()
def setUp(self):
self.state = Mock(autospec=State)
self.state.get_measurement.return_value = 10000000
del GenesisBlock.instance # Removing Singleton instance
self.genesis_block = GenesisBlock()
self.chain_manager = ChainManager(self.state)
self.chain_manager.tx_pool = Mock()
self.chain_manager._difficulty_tracker = Mock()
def setUp(self):
self.db_state = Mock(autospec=State, name='mocked State')
# self.db_state = State()
self.qrlnode = QRLNode(mining_address=b'')
# As the QRLNode is instantiated and torn down for each test, the minuscule or negative diff between present
# time and start_time can cause problems.
self.qrlnode.start_time -= 10
self.qrlnode._pow = Mock(autospec=POW)
self.qrlnode._pow.miner.lock.__enter__ = Mock()
self.qrlnode._pow.miner.lock.__exit__ = Mock()
self.qrlnode.peer_manager = Mock(autospec=P2PPeerManager,
name='mock P2PPeerManager',
known_peer_addresses=set())
self.qrlnode.p2pchain_manager = Mock(autospec=P2PChainManager,
name='mock P2PChainManager')
self.chain_manager = ChainManager(self.db_state)
self.chain_manager.tx_pool = Mock(autospec=TransactionPool)
mock_last_block = Mock(autospec=Block,
name='mock last Block',
block_number=2,
headerhash=b'deadbeef')
self.chain_manager._last_block = mock_last_block
self.chain_manager.get_unconfirmed_transaction = Mock()
self.qrlnode.set_chain_manager(self.chain_manager)
def test_create_factory(self):
factory = P2PFactory(chain_manager=ChainManager(None),
sync_state=None,
qrl_node=None)
self.assertEqual(
P2PProtocol, factory.protocol,
"Factory has not been assigned the expected protocol")
def setUp(self):
# You have to set_qrl_dir to an empty one, otherwise State will have some Transactions from disk
with set_qrl_dir('no_data'):
self.db_state = State()
self.chainmanager = ChainManager(self.db_state)
self.qrlnode = QRLNode(mining_address=b'')
self.qrlnode.set_chain_manager(self.chainmanager)
def test_getBlockByNumber(self):
db_state = Mock(spec=State)
db_state.get_tx_metadata = MagicMock(return_value=None)
db_state.get_block = MagicMock(return_value=None)
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(block_number=1,
prev_headerhash=sha256(b'reveal'),
prev_timestamp=10,
transactions=[],
miner_address=alice_xmss.address)
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_getBlock(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)
db_state.get_block = MagicMock(return_value=b)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetBlockReq(header_hash=b.headerhash)
response = service.GetBlock(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(1, response.block.header.block_number)
def setUp(self):
self.m_qrlnode = Mock(autospec=QRLNode, name='Fake QRLNode')
self.m_qrlnode.peer_manager = Mock(autospec=P2PPeerManager,
name='Fake PeerManager')
self.m_qrlnode.peer_manager.is_banned.return_value = False
self.m_qrlnode.peer_manager.load_known_peers.return_value = [
'8.8.8.8', '9.9.9.9'
]
self.channel_1 = Mock(autospec=P2PProtocol,
name='mock Channel 1',
peer=IPMetadata('1.1.1.1',
config.user.p2p_public_port))
self.channel_2 = Mock(autospec=P2PProtocol,
name='mock Channel 2',
peer=IPMetadata('2.2.2.2',
config.user.p2p_public_port))
self.channel_3 = Mock(autospec=P2PProtocol,
name='mock Channel 3',
peer=IPMetadata('3.3.3.3',
config.user.p2p_public_port))
self.factory = P2PFactory(
chain_manager=ChainManager(state=Mock(autospec=State)),
sync_state=None,
qrl_node=self.m_qrlnode)
self.factory.pow = Mock(autospec=POW)
self.factory.add_connection(self.channel_1)
self.factory.add_connection(self.channel_2)
self.factory.add_connection(self.channel_3)
def test_getTransactionsByAddress(self):
db_state = Mock(spec=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)
# Find a transaction
alice_xmss = get_alice_xmss()
db_state.get_address_state = MagicMock(
return_value=AddressState.get_default(alice_xmss.address))
db_state.address_used = MagicMock(return_value=False)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetTransactionsByAddressReq(
address=alice_xmss.address)
response = service.GetTransactionsByAddress(request=request,
context=context)
context.set_code.assert_not_called()
self.assertEqual(len(response.mini_transactions), 0)
self.assertEqual(response.balance, 0)
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_getTotalBalance(self):
db_state = Mock(spec=State)
xmss1 = get_alice_xmss()
xmss2 = get_alice_xmss(4)
xmss3 = get_bob_xmss(4)
address_state1 = AddressState.create(address=xmss1.address,
nonce=25,
balance=1000,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
address_state2 = AddressState.create(address=xmss2.address,
nonce=25,
balance=2000,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
address_state3 = AddressState.create(address=xmss3.address,
nonce=25,
balance=3000,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
m = MockFunction()
m.put(xmss1.address, address_state1)
m.put(xmss2.address, address_state2)
m.put(xmss3.address, address_state3)
db_state.get_address_state = m.get
p2p_factory = Mock(spec=P2PFactory)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
service.GetAddressState(request=request, context=context)
context.set_code.assert_called()
context.set_details.assert_called()
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetTotalBalanceReq()
request.addresses.extend([xmss1.address, xmss2.address, xmss3.address])
response = service.GetTotalBalance(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(6000, response.balance)
def test_transferCoins_get_unsigned(self):
with set_data_dir('no_data'):
with State() as db_state:
with set_wallet_dir("test_wallet"):
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(db_state, slaves=[])
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)
context = Mock(spec=ServicerContext)
alice = get_alice_xmss()
bob = get_bob_xmss()
request = qrl_pb2.TransferCoinsReq(
address_from=alice.address,
addresses_to=[bob.address],
amounts=[101],
fee=12,
xmss_pk=alice.pk)
response = service.TransferCoins(request=request,
context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertIsNotNone(response)
self.assertIsNotNone(response.transaction_unsigned)
self.assertEqual(
'transfer',
response.transaction_unsigned.WhichOneof(
'transactionType'))
self.assertEqual(alice.address,
response.transaction_unsigned.addr_from)
self.assertEqual(12, response.transaction_unsigned.fee)
self.assertEqual(alice.pk,
response.transaction_unsigned.public_key)
self.assertEqual(0, response.transaction_unsigned.nonce)
self.assertEqual(b'',
response.transaction_unsigned.signature)
self.assertEqual(
b'', response.transaction_unsigned.transaction_hash)
self.assertEqual(
bob.address,
response.transaction_unsigned.transfer.addrs_to[0])
self.assertEqual(
101, response.transaction_unsigned.transfer.amounts[0])
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 test_check_mock_get(self, mock_get_block):
with set_qrl_dir('no_data'):
with State() as state:
self.assertIsNotNone(
state) # to avoid warning (unused variable)
chain_manager = ChainManager(state)
mock_get_block.side_effect = TestStateMeasurement.get_block_example1
block = chain_manager.get_block(b'1')
self.assertEqual(1, block.block_number)
self.assertEqual(160, block.timestamp)
block = chain_manager.get_block(b'3')
self.assertEqual(3, block.block_number)
self.assertEqual(310, block.timestamp)
block = chain_manager.get_block(b'0')
self.assertEqual(0, block.block_number)
self.assertEqual(10, block.timestamp)
def setUp(self):
state = Mock()
self.m_chain_manager = ChainManager(state=state)
self.m_chain_manager._last_block = None
self.m_chain_manager._state.get_block_by_number.return_value = None
self.m_peer_manager = Mock(name='mock P2PPeerManager')
self.qrlnode = QRLNode(mining_address=b'')
self.qrlnode.set_chain_manager(self.m_chain_manager)
self.qrlnode.peer_manager = self.m_peer_manager
def test_measurement_4(self, mock_get_block):
db_name = config.dev.db_name
with mock.patch('qrl.core.config.dev') as devconfig:
devconfig.N_measurement = 3
devconfig.db_name = db_name
with set_qrl_dir('no_data'):
with State() as state:
self.assertIsNotNone(
state) # to avoid warning (unused variable)
chain_manager = ChainManager(state)
mock_get_block.side_effect = TestStateMeasurement.get_block_example1
parent_metadata = Mock()
parent_metadata.last_N_headerhashes = [b'0', b'1', b'2']
measurement = chain_manager.get_measurement(
config.dev, 350, b'3', parent_metadata)
self.assertEqual(63, measurement)
measurement = chain_manager.get_measurement(
config.dev, 370, b'3', parent_metadata)
self.assertEqual(70, measurement)
def test_getStats(self):
db_state = Mock(spec=State)
db_state.total_coin_supply = 1000
db_state.get_measurement = MagicMock(return_value=60)
db_state.get_block_by_number = MagicMock(return_value=None)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.num_connections = 23
p2p_factory.pow = Mock()
chain_manager = ChainManager(db_state)
chain_manager._last_block = GenesisBlock()
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
service = PublicAPIService(qrlnode)
request = qrl_pb2.GetStatsReq()
stats = service.GetStats(request=request, context=None)
# self.assertEqual(__version__, stats.node_info.version) # FIXME
self.assertEqual(qrl_pb2.NodeInfo.UNSYNCED, stats.node_info.state)
self.assertEqual(23, stats.node_info.num_connections)
# self.assertEqual("testnet", stats.node_info.network_id) # FIXME
self.assertEqual(0, stats.epoch)
self.assertEqual(0, stats.uptime_network)
self.assertEqual(65000000000000000, stats.block_last_reward)
self.assertEqual(0, stats.block_time_mean)
self.assertEqual(0, stats.block_time_sd)
self.assertEqual(105000000, stats.coins_total_supply)
self.assertEqual(1000, stats.coins_emitted)
self.assertEqual(0, len(stats.block_timeseries))
def test_transferCoins_push_unsigned(self):
with set_qrl_dir('wallet_ver1'):
with State() as db_state:
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(db_state, 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)
context = Mock(spec=ServicerContext)
alice = get_alice_xmss()
bob = get_bob_xmss()
request = qrl_pb2.TransferCoinsReq(
addresses_to=[bob.address],
amounts=[101],
fee=12,
xmss_pk=alice.pk
)
response = service.TransferCoins(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertIsNotNone(response)
self.assertIsNotNone(response.extended_transaction_unsigned)
self.assertEqual('transfer', response.extended_transaction_unsigned.tx.WhichOneof('transactionType'))
self.assertEqual(12, response.extended_transaction_unsigned.tx.fee)
self.assertEqual(alice.pk, response.extended_transaction_unsigned.tx.public_key)
self.assertEqual(0, response.extended_transaction_unsigned.tx.nonce)
self.assertEqual(b'', response.extended_transaction_unsigned.tx.signature)
self.assertEqual(b'', response.extended_transaction_unsigned.tx.transaction_hash)
self.assertEqual(bob.address, response.extended_transaction_unsigned.tx.transfer.addrs_to[0])
self.assertEqual(101, response.extended_transaction_unsigned.tx.transfer.amounts[0])
req_push = qrl_pb2.PushTransactionReq(transaction_signed=response.extended_transaction_unsigned.tx)
resp_push = service.PushTransaction(req_push, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertIsNotNone(resp_push)
self.assertEqual(qrl_pb2.PushTransactionResp.VALIDATION_FAILED,
resp_push.error_code)
def main():
args = parse_arguments()
config.create_path(config.user.wallet_dir)
slaves = mining_wallet_checks(args)
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, slaves=slaves)
qrlnode.set_chain(chain_manager)
set_logger(args, qrlnode.sync_state)
#######
# NOTE: Keep assigned to a variable or might get collected
admin_service, grpc_service = start_services(qrlnode)
qrlnode.start_listening()
qrlnode.connect_peers()
qrlnode.start_pow()
logger.info('QRL blockchain ledger %s', config.dev.version)
logger.info('mining/staking address %s', slaves[0])
# FIXME: This will be removed once we move away from Twisted
reactor.run()
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_getTransaction(self):
db_state = Mock(spec=State)
db_state.get_tx_metadata = MagicMock(return_value=None)
db_state.get_block = MagicMock(return_value=None)
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)
# Find an address
bob_xmss = get_bob_xmss()
# Find a transaction
alice_xmss = get_alice_xmss()
db_state.address_used = MagicMock(return_value=False)
tx1 = TransferTransaction.create(
addrs_to=[bob_xmss.address],
amounts=[125],
message_data=None,
fee=19,
xmss_pk=bob_xmss.pk,
master_addr=alice_xmss.address)
chain_manager.tx_pool.transaction_pool = [(0, TransactionInfo(tx1, 0))]
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetTransactionReq()
request.tx_hash = tx1.txhash
response = service.GetTransaction(request=request, context=context)
context.set_code.assert_not_called()
self.assertIsNotNone(response.tx)
self.assertEqual('transfer', response.tx.WhichOneof('transactionType'))
self.assertEqual(alice_xmss.address, response.tx.master_addr)
self.assertEqual(bob_xmss.pk, response.tx.public_key)
self.assertEqual(tx1.txhash, response.tx.transaction_hash)
self.assertEqual(b'', response.tx.signature)
self.assertEqual(bob_xmss.address, response.tx.transfer.addrs_to[0])
self.assertEqual(125, response.tx.transfer.amounts[0])
self.assertEqual(19, response.tx.fee)
def main():
persistent_state = State()
chain_manager = ChainManager(state=persistent_state)
chain_manager.load(GenesisBlock())
ph = PoWHelper()
difficulty = StringToUInt256('5000')
filename = os.path.expanduser(
"~/crypto/qryptonight/modeling/blockdata.csv")
with open(filename, 'w') as f:
f.write("i,timestamp,prev_timestamp,delta,difficulty,target\n")
prev_timestamp = None
for i in range(chain_manager.height):
block = chain_manager.get_block_by_number(i)
if i == 0:
prev_timestamp = block.blockheader.timestamp
continue
target = ph.getTarget(difficulty)
delta = block.blockheader.timestamp - prev_timestamp
outs = "{},{},{},{},{},{}\n".format(i, block.blockheader.timestamp,
prev_timestamp, delta,
UInt256ToString(difficulty),
UInt256ToString(target))
f.write(outs)
difficulty = ph.getDifficulty(block.blockheader.timestamp,
prev_timestamp, difficulty)
difficulty = StringToUInt256(
str(max(2, int(UInt256ToString(difficulty)))))
prev_timestamp = block.blockheader.timestamp
def setUp(self):
def replacement_get_block_by_number(i):
return self.blocks[i - 1]
port = '9000'
self.m_qrlnode = Mock(autospec=QRLNode, name='Fake QRLNode')
self.factory = P2PFactory(
chain_manager=ChainManager(state=Mock(autospec=State)),
sync_state=None,
qrl_node=self.m_qrlnode)
self.factory.peer_fetch_block = Mock(
autospec=P2PFactory.peer_fetch_block)
self.factory._chain_manager.get_block_by_number = replacement_get_block_by_number
self.channel_1 = Mock(autospec=P2PProtocol,
name='mock Channel 1',
peer_ip='1.1.1.1',
peer_port=port)
self.factory.add_connection(self.channel_1)
self.blocks = [
Mock(autospec=Block,
name='0th Block',
block_number=1,
headerhash=bhstr2bin('123456')),
Mock(autospec=Block,
name='1st Block',
block_number=2,
headerhash=bhstr2bin('7890ab')),
Mock(autospec=Block,
name='2nd Block',
block_number=3,
headerhash=bhstr2bin('deadbeef'))
]
self.node_header_hash = qrl_pb2.NodeHeaderHash(
block_number=1,
headerhashes=[
bhstr2bin('123456'),
bhstr2bin('7890ab'),
bhstr2bin('deadbeef')
])
def test_getAddressState(self):
with set_qrl_dir('no_data'):
db_state = State()
alice_xmss = get_alice_xmss()
optimized_address_state = OptimizedAddressState.create(address=alice_xmss.address,
nonce=25,
balance=10,
ots_bitfield_used_page=0,
transaction_hash_count=0,
tokens_count=0,
lattice_pk_count=0,
slaves_count=0,
multi_sig_address_count=0)
AddressState.put_address_state(db_state, optimized_address_state)
p2p_factory = Mock(spec=P2PFactory)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
service.GetAddressState(request=request, context=context)
context.set_code.assert_called()
context.set_details.assert_called()
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
request.address = get_alice_xmss().address
response = service.GetAddressState(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(alice_xmss.address, response.state.address)
self.assertEqual(25, response.state.nonce)
self.assertEqual(10, response.state.balance)
self.assertEqual([b'\x00'] * config.dev.ots_bitfield_size, response.state.ots_bitfield)
self.assertEqual([], response.state.transaction_hashes)
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())
import os
from qrl.core.ChainManager import ChainManager
from qrl.core.GenesisBlock import GenesisBlock
from qrl.core.State import State
from pyqryptonight.pyqryptonight import PoWHelper, StringToUInt256, UInt256ToString
persistent_state = State()
chain_manager = ChainManager(state=persistent_state)
chain_manager.load(GenesisBlock())
ph = PoWHelper()
difficulty = StringToUInt256('5000')
delta = 0
filename = os.path.expanduser("~/crypto/qryptonight/modeling/blockdata.csv")
with open(filename, 'w') as f:
f.write("i,timestamp,prev_timestamp,delta,difficulty,boundary\n")
prev_timestamp = None
for i in range(chain_manager.height):
block = chain_manager.get_block_by_number(i)
if i == 0:
prev_timestamp = block.blockheader.timestamp
continue
boundary = ph.getBoundary(difficulty)
delta = block.blockheader.timestamp - prev_timestamp
outs = "{},{},{},{},{},{}\n".format(i,
def test_orphan_block(self):
"""
Testing add_block logic in case of orphan_blocks
:return:
"""
with mock.patch('qrl.core.config.DevConfig') as devconfig:
devconfig.genesis_difficulty = 2
devconfig.minimum_minting_delay = 10
with set_data_dir('no_data'):
with State() as state: # FIXME: Move state to temporary directory
state.get_measurement = MagicMock(return_value=10000000)
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)
alice_xmss = get_alice_xmss()
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=[],
signing_xmss=alice_xmss,
master_address=alice_xmss.get_address(),
nonce=1)
block_1.set_mining_nonce(10)
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)
bob_xmss = get_bob_xmss()
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1615270948 + devconfig.minimum_minting_delay * 2
block = Block.create(mining_nonce=18,
block_number=1,
prevblock_headerhash=genesis_block.headerhash,
transactions=[],
signing_xmss=bob_xmss,
master_address=bob_xmss.get_address(),
nonce=1)
block.set_mining_nonce(18)
while not chain_manager.validate_mining_nonce(block, False):
block.set_mining_nonce(block.mining_nonce + 1)
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1615270948 + devconfig.minimum_minting_delay * 3
block_2 = Block.create(mining_nonce=17,
block_number=2,
prevblock_headerhash=block.headerhash,
transactions=[],
signing_xmss=bob_xmss,
master_address=bob_xmss.get_address(),
nonce=2)
block_2.set_mining_nonce(17)
result = chain_manager.add_block(block_2)
self.assertTrue(result)
result = chain_manager.add_block(block)
self.assertTrue(result)
block = state.get_block(block.headerhash)
self.assertIsNotNone(block)
self.assertEqual(chain_manager.last_block.block_number, block_1.block_number)
self.assertEqual(chain_manager.last_block.headerhash, block_1.headerhash)
