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.xrdnode = xrdNode(mining_address=b'')
self.xrdnode.set_chain_manager(self.chain_manager)
self.xrdnode._p2pfactory = p2p_factory
self.xrdnode._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.xrdnode)
def test_create_fails_when_prev_timestamp_is_negative(self, time_mock):
# The only way to get it to fail in this mode is to pass a negative timestamp. Which should never happen IRL.
time_mock.return_value = 0
b = BlockHeader.create(config.dev,
1,
sha256(b'prev'),
-10,
sha256(b'txs'),
10,
seed_height=0,
seed_hash=None)
self.assertIsNone(b)
def get_data_hash(self):
tmp_tx_hash = (self.master_addr +
self.fee.to_bytes(8, byteorder='big', signed=False) +
self.shared_key +
self.unvote.to_bytes(1, byteorder='big', signed=False))
return sha256(tmp_tx_hash)
def test_getBlock(self):
with set_xrd_dir('no_data'):
db_state = State()
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager = ChainManager(db_state)
xrdnode = xrdNode(mining_address=b'')
xrdnode.set_chain_manager(chain_manager)
xrdnode._p2pfactory = p2p_factory
xrdnode._pow = p2p_factory.pow
xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(xrdnode)
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 = xrd_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):
with mock.patch('xrd.core.misc.ntp.getTime',
return_value=1615270948) as time_mock:
self.block_header = BlockHeader.create(config.dev, 1,
sha256(b'prev'),
time_mock.return_value,
sha256(b'txs'), 10, 0, None)
self.fee_reward = 10
self.coinbase_amount = self.block_header.block_reward + self.fee_reward
# this variable is for validate_parent_child_relation()
self.m_parent_block = Mock(
name='mock Parent Block',
block_number=self.block_header.block_number - 1,
headerhash=self.block_header.prev_headerhash,
timestamp=self.block_header.timestamp - 1)
def __init__(self, *args, **kwargs):
super(TestCoinBase, self).__init__(*args, **kwargs)
with set_xrd_dir('no_data'):
self.state = State()
self.alice = get_alice_xmss()
self.alice.set_ots_index(11)
self.mock_blockheader = Mock(spec=BlockHeader)
self.mock_blockheader.stake_selector = self.alice.address
self.mock_blockheader.block_reward = 50
self.mock_blockheader.fee_reward = 40
self.mock_blockheader.prev_headerhash = sha256(b'prev_headerhash')
self.mock_blockheader.block_number = 1
self.mock_blockheader.headerhash = sha256(b'headerhash')
self.amount = self.mock_blockheader.block_reward + self.mock_blockheader.fee_reward
self.maxDiff = None
def get_data_hash(self):
tmptxhash = (self.master_addr +
self.fee.to_bytes(8, byteorder='big', signed=False) +
self.threshold.to_bytes(8, byteorder='big', signed=False))
for index in range(0, len(self.signatories)):
tmptxhash = (tmptxhash +
self.signatories[index] +
self.weights[index].to_bytes(8, byteorder='big', signed=False))
return sha256(tmptxhash)
def get_data_hash(self):
tmp_tx_hash = (self.master_addr +
self.fee.to_bytes(8, byteorder='big', signed=False) +
self.multi_sig_address +
self.expiry_block_number.to_bytes(8, byteorder='big', signed=False))
for index in range(0, len(self.addrs_to)):
tmp_tx_hash = (tmp_tx_hash +
self.addrs_to[index] +
self.amounts[index].to_bytes(8, byteorder='big', signed=False))
return sha256(tmp_tx_hash)
def test_handle_block_height_incoming_information(self, m_logger):
"""
If the incoming message.bhData.block_number is not 0, this means that we should update our knowledge of the
peer's blockheight.
"""
some_cumulative_difficulty = bytes(StringToUInt256('0'))
incoming_info = make_message(
func_name=xrdlegacy_pb2.LegacyMessage.BH,
bhData=xrd_pb2.BlockHeightData(
block_number=1,
block_headerhash=sha256(b'some_hash'),
cumulative_difficulty=some_cumulative_difficulty))
self.manager.handle_block_height(self.channel, incoming_info)
self.channel.send.assert_not_called()
self.channel.factory.update_peer_blockheight.assert_called()
def test_block_reward_calc_genesis_is_total_coin_supply(self, time_mock):
genesis = BlockHeader.create(config.dev, 0,
sha256(b'Random Scifi Book Title'),
time_mock.return_value, sha256(b'txs'),
10, 0, None)
self.assertEqual(config.dev.supplied_coins, genesis.block_reward)
def test_create_uses_prev_timestamp_when_genesis_block(self, time_mock):
genesis = BlockHeader.create(config.dev, 0,
sha256(b'Random Scifi Book Title'),
time_mock.return_value, sha256(b'txs'),
10, 0, None)
self.assertEqual(genesis.timestamp, time_mock.return_value)
def __init__(self, key_str: str):
self.key = key_str.encode()
self.key_hash = sha256(self.key)
def get_data_hash(self) -> bytes:
"""
This method returns the hashes of the transaction data.
:return:
"""
return sha256(self.get_data_bytes())
def generate_txhash(self):
return sha256(self.get_data_hash() + self.signature + self.PK)
def test_transferCoins_sign(self):
with set_xrd_dir('wallet_ver1'):
with State() as db_state:
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager = ChainManager(db_state)
xrdnode = xrdNode(mining_address=b'')
xrdnode.set_chain_manager(chain_manager)
xrdnode._p2pfactory = p2p_factory
xrdnode._pow = p2p_factory.pow
xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(xrdnode)
context = Mock(spec=ServicerContext)
alice = get_alice_xmss()
bob = get_bob_xmss()
request = xrd_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.tx)
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])
tmp_hash_pre = bytes(xrdHelper.getAddress(response.extended_transaction_unsigned.tx.public_key))
tmp_hash_pre += str(response.extended_transaction_unsigned.tx.fee).encode()
tmp_hash_pre += response.extended_transaction_unsigned.tx.transfer.addrs_to[0]
tmp_hash_pre += str(response.extended_transaction_unsigned.tx.transfer.amounts[0]).encode()
self.assertEqual('010300a1da274e68c88b0ccf448e0b1916fa789b01eb2ed4e9ad565ce264c939078'
'2a9c61ac02f31320103001d65d7e59aed5efbeae64246e0f3184d7c42411421eb38'
'5ba30f2c1c005a85ebc4419cfd313031',
bin2hstr(tmp_hash_pre))
tmp_hash = sha256(tmp_hash_pre)
self.assertEqual('3645f2819aba65479f9a7fad3f5d7a41a9357410a595fa02fb947bfe3ed96e0f',
bin2hstr(tmp_hash))
signed_transaction = response.extended_transaction_unsigned.tx
signed_transaction.signature = alice.sign(tmp_hash)
req_push = xrd_pb2.PushTransactionReq(transaction_signed=signed_transaction)
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(xrd_pb2.PushTransactionResp.SUBMITTED,
resp_push.error_code)
self.assertEqual('30955fdc5e2d9dbe5fb9bf812f2e1b6c4b409a8a7c7a75f1c3e9ba1ffdd8e60e',
bin2hstr(resp_push.tx_hash))
def test_getLatestData(self):
with set_xrd_dir('no_data'):
db_state = State()
chain_manager = ChainManager(db_state)
blocks = []
txs = []
alice_xmss = get_alice_xmss()
bob_xmss = get_bob_xmss()
for i in range(0, 4):
for j in range(1, 3):
txs.append(TransferTransaction.create(addrs_to=[bob_xmss.address],
amounts=[i * 100 + j],
message_data=None,
fee=j,
xmss_pk=alice_xmss.pk))
blocks.append(Block.create(dev_config=config.dev,
block_number=i,
prev_headerhash=sha256(b'reveal'),
prev_timestamp=10,
transactions=txs,
miner_address=alice_xmss.address,
seed_height=10,
seed_hash=None))
block = blocks[i]
Block.put_block(db_state,
block,
None)
Block.put_block_number_mapping(db_state,
block.block_number,
xrd_pb2.BlockNumberMapping(headerhash=block.headerhash),
None)
TransactionMetadata.update_tx_metadata(db_state, block, None)
chain_manager._last_block = blocks[-1]
txpool = []
txs = []
for j in range(10, 15):
tx = TransferTransaction.create(addrs_to=[bob_xmss.address],
amounts=[1000 + j],
message_data=None,
fee=j,
xmss_pk=get_alice_xmss().pk)
txpool.append((tx.fee, TransactionInfo(tx, 0)))
txs.append(tx)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager.tx_pool = Mock()
chain_manager.tx_pool.transactions = heapq.nlargest(len(txpool), txpool)
chain_manager.tx_pool.transaction_pool = txpool
xrdnode = xrdNode(mining_address=b'')
xrdnode.set_chain_manager(chain_manager)
xrdnode.get_block_from_index = MagicMock(return_value=None)
xrdnode._p2pfactory = p2p_factory
xrdnode._pow = p2p_factory.pow
service = PublicAPIService(xrdnode)
context = Mock(spec=ServicerContext)
request = xrd_pb2.GetLatestDataReq(filter=xrd_pb2.GetLatestDataReq.ALL,
offset=0,
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(3, len(response.blockheaders))
self.assertEqual(1, response.blockheaders[0].header.block_number)
self.assertEqual(2, response.blockheaders[1].header.block_number)
self.assertEqual(3, response.blockheaders[2].header.block_number)
# Verify transactions_unconfirmed
self.assertEqual(3, len(response.transactions_unconfirmed))
# TODO: Verify expected order
self.assertEqual(1014, response.transactions_unconfirmed[0].tx.transfer.amounts[0])
self.assertEqual(1013, response.transactions_unconfirmed[1].tx.transfer.amounts[0])
self.assertEqual(1012, response.transactions_unconfirmed[2].tx.transfer.amounts[0])
# Verify transactions
self.assertEqual(3, len(response.transactions))
self.assertEqual(2, response.transactions[0].tx.fee)
self.assertEqual(1, response.transactions[1].tx.fee)
self.assertEqual(2, response.transactions[2].tx.fee)
self.assertEqual(302, response.transactions[0].tx.transfer.amounts[0])
self.assertEqual(301, response.transactions[1].tx.transfer.amounts[0])
self.assertEqual(202, response.transactions[2].tx.transfer.amounts[0])
def test_getObject(self):
SOME_ODD_HASH = sha256(b'this should not be found')
with set_xrd_dir('no_data'):
db_state = State()
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager = ChainManager(db_state)
xrdnode = xrdNode(mining_address=b'')
xrdnode.set_chain_manager(chain_manager)
xrdnode._p2pfactory = p2p_factory
xrdnode._pow = p2p_factory.pow
xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(xrdnode)
# First try an empty request
context = Mock(spec=ServicerContext)
request = xrd_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)
# Some odd address
context = Mock(spec=ServicerContext)
request = xrd_pb2.GetObjectReq()
request.query = SOME_ODD_HASH
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertFalse(response.found)
# Find an address
bob_xmss = get_bob_xmss()
addr1_state = OptimizedAddressState.create(address=bob_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, addr1_state, None)
context = Mock(spec=ServicerContext)
request = xrd_pb2.GetObjectReq()
request.query = bob_xmss.address
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.address_state)
self.assertEqual(bob_xmss.address, response.address_state.address)
self.assertEqual(25, response.address_state.nonce)
self.assertEqual(10, response.address_state.balance)
# 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 = xrd_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('transfer', response.transaction.tx.WhichOneof('transactionType'))
self.assertEqual(alice_xmss.address, response.transaction.tx.master_addr)
self.assertEqual(bob_xmss.pk, response.transaction.tx.public_key)
self.assertEqual(tx1.txhash, response.transaction.tx.transaction_hash)
self.assertEqual(b'', response.transaction.tx.signature)
self.assertEqual(bob_xmss.address, response.transaction.tx.transfer.addrs_to[0])
self.assertEqual(125, response.transaction.tx.transfer.amounts[0])
self.assertEqual(19, response.transaction.tx.fee)
alice_xmss = get_alice_xmss()
# Find a block
block = 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, block, None)
Block.put_block_number_mapping(db_state,
block.block_number,
xrd_pb2.BlockNumberMapping(headerhash=block.headerhash),
None)
context = Mock(spec=ServicerContext)
request = xrd_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_extended)
self.assertEqual(1, response.block_extended.header.block_number)
def test_messageTxn_sign(self):
with set_xrd_dir('wallet_ver1'):
with State() as db_state:
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager = ChainManager(db_state)
xrdnode = xrdNode(mining_address=b'')
xrdnode.set_chain_manager(chain_manager)
xrdnode._p2pfactory = p2p_factory
xrdnode._pow = p2p_factory.pow
xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(xrdnode)
context = Mock(spec=ServicerContext)
alice = get_alice_xmss()
my_message = b'Hello xrd!'
request = xrd_pb2.MessageTxnReq(
message=my_message,
fee=12,
xmss_pk=alice.pk
)
response = service.GetMessageTxn(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.tx)
self.assertEqual('message', 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(my_message, response.extended_transaction_unsigned.tx.message.message_hash)
tmp_hash_pre = response.extended_transaction_unsigned.tx.master_addr
tmp_hash_pre += response.extended_transaction_unsigned.tx.fee.to_bytes(8, byteorder='big', signed=False)
tmp_hash_pre += response.extended_transaction_unsigned.tx.message.message_hash
tmp_hash = sha256(tmp_hash_pre)
hash_found = bin2hstr(Transaction.from_pbdata(response.extended_transaction_unsigned.tx).
get_data_hash())
self.assertEqual(hash_found,
bin2hstr(tmp_hash))
signed_transaction = response.extended_transaction_unsigned.tx
signed_transaction.signature = alice.sign(tmp_hash)
req_push = xrd_pb2.PushTransactionReq(transaction_signed=signed_transaction)
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(xrd_pb2.PushTransactionResp.SUBMITTED,
resp_push.error_code)
self.assertEqual('b7ee814a548a6bbb8d97b2d3a0eb9e1f8b6ceee49b764e3c7b23d104aca6abeb',
bin2hstr(resp_push.tx_hash))
