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_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):
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 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_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 test_getNodeState(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)
service = PublicAPIService(qrlnode)
node_state = service.GetNodeState(request=qrl_pb2.GetNodeStateReq,
context=None)
# self.assertEqual(__version__, node_state.info.version) # FIXME
self.assertEqual(qrl_pb2.NodeInfo.UNSYNCED, node_state.info.state)
self.assertEqual(23, node_state.info.num_connections)
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 test_getLatestData(self):
blocks = []
txs = []
for i in range(1, 4):
for j in range(1, 3):
txs.append(
TransferTransaction.create(addr_from=qrladdress('source'),
addr_to=qrladdress('dest'),
amount=i * 100 + j,
fee=j,
xmss_pk=get_alice_xmss().pk(),
xmss_ots_index=i))
blocks.append(
Block.create(staking_address=qrladdress('staking_addr'),
block_number=i,
reveal_hash=sha256(b'reveal'),
prevblock_headerhash=sha256(b'reveal'),
transactions=txs,
duplicate_transactions=OrderedDict(),
vote=VoteMetadata(),
signing_xmss=get_alice_xmss(),
nonce=i))
txpool = []
for j in range(10, 15):
txpool.append(
TransferTransaction.create(addr_from=qrladdress('source'),
addr_to=qrladdress('dest'),
amount=1000 + j,
fee=j,
xmss_pk=get_alice_xmss().pk(),
xmss_ots_index=j))
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.tx_pool = Mock()
buffered_chain.tx_pool.transaction_pool = txpool
buffered_chain.get_block = Mock()
buffered_chain.get_block.side_effect = blocks
buffered_chain.height = len(blocks)
buffered_chain._chain = Mock()
buffered_chain._chain.blockchain = blocks
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetLatestDataReq(filter=qrl_pb2.GetLatestDataReq.ALL,
offset=1,
quantity=3)
response = service.GetLatestData(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
# Verify blockheaders
self.assertEqual(2, len(response.blockheaders))
self.assertEqual(1, response.blockheaders[0].header.block_number)
self.assertEqual(2, response.blockheaders[1].header.block_number)
# Verify transactions
self.assertEqual(3, len(response.transactions))
self.assertEqual(1, response.transactions[0].transfer.fee)
self.assertEqual(2, response.transactions[1].transfer.fee)
self.assertEqual(1, response.transactions[2].transfer.fee)
# 302 should have been skipped
self.assertEqual(301, response.transactions[0].transfer.amount)
self.assertEqual(202, response.transactions[1].transfer.amount)
self.assertEqual(201, response.transactions[2].transfer.amount)
# Verify transactions_unconfirmed
self.assertEqual(3, len(response.transactions_unconfirmed))
self.assertEqual(1013,
response.transactions_unconfirmed[0].transfer.amount)
self.assertEqual(1012,
response.transactions_unconfirmed[1].transfer.amount)
self.assertEqual(1011,
response.transactions_unconfirmed[2].transfer.amount)
def test_getObject(self):
SOME_ODD_HASH = sha256(b'this should not be found')
SOME_ADDR1 = b'Q' + sha256(b'address1')
SOME_ADDR2 = b'Q' + sha256(b'address2')
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.tx_pool = Mock()
buffered_chain.tx_pool.transaction_pool = []
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.GetObjectReq()
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertFalse(response.found)
# Find an address
db_state.get_address = MagicMock(return_value=AddressState.create(
address=SOME_ADDR1,
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')])
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = SOME_ODD_HASH
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertFalse(response.found)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = SOME_ADDR1
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.address_state)
self.assertEqual(SOME_ADDR1, response.address_state.address)
self.assertEqual(25, response.address_state.nonce)
self.assertEqual(10, response.address_state.balance)
self.assertEqual([sha256(b'a'), sha256(b'b')],
response.address_state.pubhashes)
self.assertEqual([sha256(b'0'), sha256(b'1')],
response.address_state.transaction_hashes)
# Find a transaction
db_state.address_used = MagicMock(return_value=False)
tx1 = TransferTransaction.create(addr_from=SOME_ADDR1,
addr_to=SOME_ADDR2,
amount=125,
fee=19,
xmss_pk=sha256(b'pk'),
xmss_ots_index=13)
buffered_chain.tx_pool.transaction_pool = [tx1]
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = tx1.txhash
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.transaction)
self.assertEqual(qrl_pb2.Transaction.TRANSFER,
response.transaction.type)
self.assertEqual(SOME_ADDR1, response.transaction.addr_from)
self.assertEqual(sha256(b'pk'), response.transaction.public_key)
self.assertEqual(tx1.txhash, response.transaction.transaction_hash)
self.assertEqual(13, response.transaction.ots_key)
self.assertEqual(b'', response.transaction.signature)
self.assertEqual(SOME_ADDR2, response.transaction.transfer.addr_to)
self.assertEqual(125, response.transaction.transfer.amount)
self.assertEqual(19, response.transaction.transfer.fee)
# Find a block
buffered_chain.get_block = MagicMock(return_value=Block.create(
staking_address=qrladdress('staking_addr'),
block_number=1,
reveal_hash=sha256(b'reveal'),
prevblock_headerhash=sha256(b'reveal'),
transactions=[],
duplicate_transactions=OrderedDict(),
vote=VoteMetadata(),
signing_xmss=get_alice_xmss(),
nonce=1))
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = bytes(str2bin('1'))
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.block)
self.assertEqual(1, response.block.header.block_number)
def main():
parser = argparse.ArgumentParser(description='QRL node')
parser.add_argument('--quiet',
'-q',
dest='quiet',
action='store_true',
required=False,
default=False,
help="Avoid writing data to the console")
parser.add_argument('--datapath',
'-d',
dest='data_path',
default=config.user.data_path,
help="Retrieve data from a different path")
parser.add_argument('--walletpath',
'-w',
dest='wallet_path',
default=config.user.wallet_path,
help="Retrieve wallet from a different path")
parser.add_argument('--no-colors',
dest='no_colors',
action='store_true',
default=False,
help="Disables color output")
parser.add_argument(
"-l",
"--loglevel",
dest="logLevel",
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
help="Set the logging level")
parser.add_argument("--get-wallets",
dest="get_wallets",
action='store_true',
default=False,
help="Returns wallet address and stops the node")
args = parser.parse_args()
node_state = NodeState()
# Logging configuration
log_level = logging.INFO
if args.logLevel:
log_level = getattr(logging, args.logLevel)
logger.initialize_default(
force_console_output=not args.quiet).setLevel(log_level)
custom_filter = ContextFilter(node_state)
logger.logger.addFilter(custom_filter)
file_handler = logger.log_to_file()
file_handler.addFilter(custom_filter)
file_handler.setLevel(logging.DEBUG)
logger.set_colors(not args.no_colors, LOG_FORMAT_CUSTOM)
logger.set_unhandled_exception_handler()
logger_twisted.enable_twisted_log_observer()
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)
ntp.setDrift()
logger.info('Initializing chain..')
state_obj = State()
chain_obj = Chain(state=state_obj)
qrlnode = QRLNode(db_state=state_obj)
qrlnode.set_chain(chain_obj)
logger.info('QRL blockchain ledger %s', config.dev.version_number)
logger.info('mining/staking address %s', chain_obj.mining_address)
if args.get_wallets:
address_data = chain_obj.wallet.list_addresses(
chain_obj.state, chain_obj.transaction_pool)
addresses = [a[0] for a in address_data]
print((addresses[0]))
return
#######
# NOTE: Keep assigned to a variable or it will be collected
qrlserver = start_services(qrlnode)
#######
logger.info('Reading chain..')
chain_obj.m_load_chain()
logger.info(str(len(chain_obj.m_blockchain)) + ' blocks')
logger.info('Verifying chain')
logger.info('Building state leveldb')
# FIXME: Again, we have cross-references between node, factory, chain and node_state
p2p_factory = P2PFactory(chain=chain_obj,
nodeState=node_state,
node=qrlnode)
pos = POS(chain=chain_obj,
p2pFactory=p2p_factory,
nodeState=node_state,
ntp=ntp)
p2p_factory.setPOS(pos)
qrlnode.set_p2pfactory(p2p_factory)
# FIXME: Again, we have cross-references between node, factory, chain and node_state
api_factory = ApiFactory(pos, chain_obj, state_obj,
p2p_factory.peer_connections)
welcome = 'QRL node connection established. Try starting with "help"\r\n'
# FIXME: Again, we have cross-references between node, factory, chain and node_state
wallet_factory = WalletFactory(welcome, chain_obj, state_obj, p2p_factory,
api_factory, qrlnode)
logger.info('>>>Listening..')
reactor.listenTCP(2000, wallet_factory, interface='127.0.0.1')
reactor.listenTCP(9000, p2p_factory)
reactor.listenTCP(8080, api_factory)
webwallet.WebWallet(chain_obj, state_obj, p2p_factory, qrlnode)
pos.restart_monitor_bk(80)
logger.info(
'Connect to the node via telnet session on port 2000: i.e "telnet localhost 2000"'
)
p2p_factory.connect_peers()
reactor.callLater(20, pos.unsynced_logic)
reactor.run()
