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_GetAddressFromPK(self):
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pow = Mock()
chain_manager = Mock(spec=ChainManager)
chain_manager.height = 0
qrlnode = QRLNode(db_state, mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
service = PublicAPIService(qrlnode)
pk = hstr2bin(
'01060057ac9cb6085a8135631dcf018dff46d9c368a0b64d508f512e584199b6800'
'f8cfcb672b931398a023680fe0308ed4b6ec75877d684bc2ccf11703e8369f064e7'
)
request = qrl_pb2.GetAddressFromPKReq(pk=bytes(pk))
response = service.GetAddressFromPK(request=request, context=None)
self.assertEqual(
'010600b56d161c7de8aa741962e3e49b973b7e53456fa47f2443d69f17c632f29c8b1aab7d2491',
bin2hstr(response.address))
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_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 setUp(self):
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.num_connections = 23
p2p_factory.pow = Mock()
b = Block()
self.chain_manager = Mock(spec=ChainManager)
self.chain_manager.height = 0
self.chain_manager.get_last_block = MagicMock(return_value=b)
self.chain_manager.get_block_header_hash_by_number = MagicMock(
return_value=b.headerhash)
self.qrlnode = QRLNode(mining_address=b'')
self.qrlnode.set_chain_manager(self.chain_manager)
self.qrlnode._p2pfactory = p2p_factory
self.qrlnode._pow = p2p_factory.pow
self.block_header_params = {
"dev_config": config.dev,
"blocknumber": 10,
"prev_headerhash": sha256(b'prevblock'),
"prev_timestamp": 1234567890,
"hashedtransactions": sha256(b'tx1'),
"fee_reward": 1,
"seed_height": 0,
"seed_hash": None,
}
self.service = MiningAPIService(self.qrlnode)
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 test_getKnownPeers(self):
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pos = Mock()
p2p_factory.pos.stake = False
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.height = 0
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
response = service.GetKnownPeers(request=qrl_pb2.GetKnownPeersReq,
context=None)
self.assertEqual(2, len(response.known_peers))
self.assertEqual('127.0.0.1', response.known_peers[0].ip)
self.assertEqual('192.168.1.1', response.known_peers[1].ip)
logger.info(response)
def test_getKnownPeers(self):
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.num_connections = 23
p2p_factory.pow = Mock()
chain_manager = Mock(spec=ChainManager)
chain_manager.height = 0
chain_manager.last_block = Block()
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
qrlnode.peer_manager = Mock()
qrlnode.peer_manager.known_peer_addresses = [
'127.0.0.1', '192.168.1.1'
]
service = PublicAPIService(qrlnode)
response = service.GetKnownPeers(request=qrl_pb2.GetKnownPeersReq,
context=None)
self.assertEqual(2, len(response.known_peers))
self.assertEqual('127.0.0.1', response.known_peers[0].ip)
self.assertEqual('192.168.1.1', response.known_peers[1].ip)
logger.info(response)
def test_GetBlockMiningCompatible(self):
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.num_connections = 23
p2p_factory.pow = Mock()
chain_manager = Mock(spec=ChainManager)
chain_manager.height = 0
chain_manager.get_last_block = MagicMock(return_value=Block())
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
block_header = BlockHeader.create(blocknumber=10,
prev_headerhash=sha256(b'prevblock'),
prev_timestamp=1234567890,
hashedtransactions=sha256(b'tx1'),
fee_reward=1)
qrlnode.get_blockheader_and_metadata = MagicMock(
return_value=[block_header, BlockMetadata()])
service = MiningAPIService(qrlnode)
req = qrlmining_pb2.GetBlockMiningCompatibleReq(height=10)
answer = service.GetBlockMiningCompatible(request=req, context=None)
self.assertEqual(10, answer.blockheader.block_number)
self.assertEqual(1, answer.blockheader.reward_fee)
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 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 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_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 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_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 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_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 test_getStakers(self):
db_state = Mock(spec=State)
db_state.stake_validators_tracker = Mock(spec=StakeValidatorsTracker)
db_state.stake_validators_tracker.sv_dict = dict()
p2p_factory = Mock(spec=P2PFactory)
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.tx_pool = Mock()
buffered_chain.get_block = Mock()
buffered_chain._chain = Mock()
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetStakersReq(filter=qrl_pb2.GetStakersReq.CURRENT,
offset=0,
quantity=3)
response = service.GetStakers(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertEqual(0, len(response.stakers))
# Add a few validators
stake_tx = StakeTransaction.create(1, get_alice_xmss(),
get_bob_xmss().pk(),
sha256(b'terminator'))
expected_address = bytes(get_alice_xmss().get_address().encode())
db_state.get_address = MagicMock(
return_value=AddressState.create(address=expected_address,
nonce=1,
balance=100,
pubhashes=[],
tokens=dict()))
db_state.get_address_tx_hashes = MagicMock(return_value=[])
validator1 = StakeValidator.create(100, stake_tx)
db_state.stake_validators_tracker.sv_dict[
validator1.address] = validator1
request = qrl_pb2.GetStakersReq(filter=qrl_pb2.GetStakersReq.CURRENT,
offset=0,
quantity=3)
response = service.GetStakers(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertEqual(1, len(response.stakers))
self.assertEqual(expected_address,
response.stakers[0].address_state.address)
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_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 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 test_getNodeInfo(self):
qrlnode = QRLNode(mining_address=b'')
service = BaseService(qrlnode)
response = service.GetNodeInfo(request=GetNodeInfoReq, context=None)
self.assertEqual(config.dev.version, response.version)
proto_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), os.path.pardir,
os.path.pardir, "src", "qrl", "protos", "qrl.proto"))
with open(proto_path, 'r') as content_file:
proto_content = content_file.read()
self.assertEqual(proto_content, response.grpcProto)
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_getNodeInfo(self):
db_state = Mock(spec=State)
qrlnode = QRLNode(db_state, slaves=[])
service = BaseService(qrlnode)
response = service.GetNodeInfo(request=GetNodeInfoReq, context=None)
self.assertEqual(config.dev.version, response.version)
proto_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), os.path.pardir,
os.path.pardir, "qrl", "protos", "qrl.proto"))
with open(proto_path, 'r') as content_file:
proto_content = content_file.read()
self.assertEqual(proto_content, response.grpcProto)
def setUp(self):
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pos = Mock()
p2p_factory.pos.stake = False
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.height = 0
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
self.service = P2PAPIService(qrlnode)
def test_getStats(self):
db_state = Mock(spec=State)
db_state.stake_validators_tracker = StakeValidatorsTracker()
db_state.total_coin_supply = MagicMock(return_value=1000)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pos = Mock()
p2p_factory.pos.stake = False
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.height = 0
buffered_chain._chain = Mock()
buffered_chain._chain.blockchain = []
buffered_chain.get_block = MagicMock(return_value=None)
buffered_chain.state = db_state
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
service = PublicAPIService(qrlnode)
stats = service.GetStats(request=qrl_pb2.GetStatsReq, 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(0, stats.stakers_count)
self.assertEqual(0, 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, stats.coins_atstake)
logger.info(stats)
def test_create(self):
db_state = Mock(spec=State)
qrlnode = QRLNode(db_state)
with patch('qrl.generated.qrl_pb2_grpc.P2PAPIStub'):
pm = PeerManager(qrlnode)
self.assertIsNotNone(pm)
self.assertEqual(0, pm.stable_peer_count)
pm.add(['127.0.0.1'])
pm.add(['0.0.0.0'])
self.assertEqual(0, pm.peer_count)
pm.add(['1.1.1.1'])
self.assertEqual(1, pm.peer_count)
self.assertEqual(0, pm.stable_peer_count)
sleep(2)
def test_getAddressState(self):
db_state = Mock(spec=State)
db_state.get_address = MagicMock(return_value=AddressState.create(
address=b'Q' + sha256(b'address'),
nonce=25,
balance=10,
pubhashes=[sha256(b'a'), sha256(b'b')],
tokens=dict()))
db_state.get_address_tx_hashes = MagicMock(
return_value=[sha256(b'0'), sha256(b'1')])
p2p_factory = Mock(spec=P2PFactory)
chain = Chain(db_state)
buffered_chain = BufferedChain(chain)
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
response = 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 = b'Q' + sha256(b'address')
response = service.GetAddressState(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(b'Q' + sha256(b'address'), response.state.address)
self.assertEqual(25, response.state.nonce)
self.assertEqual(10, response.state.balance)
self.assertEqual([sha256(b'a'), sha256(b'b')],
response.state.pubhashes)
self.assertEqual([sha256(b'0'), sha256(b'1')],
response.state.transaction_hashes)
def main():
args = parse_arguments()
logger.debug(
"====================================================================================="
)
logger.info("Data Path: %s", args.data_path)
logger.info("Wallet Path: %s", args.wallet_path)
config.user.data_path = args.data_path
config.user.wallet_path = args.wallet_path
config.create_path(config.user.data_path)
config.create_path(config.user.wallet_path)
sync_state = SyncState()
set_logger(args, sync_state)
ntp.setDrift()
logger.info('Initializing chain..')
persistent_state = State()
buffered_chain = BufferedChain(Chain(state=persistent_state))
qrlnode = QRLNode(db_state=persistent_state)
qrlnode.set_chain(buffered_chain)
logger.info('QRL blockchain ledger %s', config.dev.version)
logger.info('mining/staking address %s', buffered_chain.staking_address)
if args.get_wallets:
tmp = qrlnode.addresses
if len(tmp) > 0:
print(tmp[0].decode())
return
#######
# NOTE: Keep assigned to a variable or might get collected
grpc_service, p2p_node = start_services(qrlnode)
buffered_chain.load()
start_legacy_services(buffered_chain, qrlnode, sync_state)
def test_getStats(self):
db_state = Mock(spec=State)
db_state.total_coin_supply = MagicMock(return_value=1000)
db_state.get_measurement = MagicMock(return_value=60)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.sync_state = SyncState()
p2p_factory.connections = 23
p2p_factory.pow = Mock()
chain_manager = Mock(spec=ChainManager)
chain_manager.height = 0
chain_manager.get_last_block = MagicMock(return_value=GenesisBlock())
chain_manager.get_block_by_number = MagicMock(return_value=None)
chain_manager.state = db_state
qrlnode = QRLNode(db_state, 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(60, 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))
