def _test_mark_blocks_and_request_cleanup(self):
marked_block = OntObjectHash(
binary=helpers.generate_bytearray(ont_constants.ONT_HASH_LEN))
prev_block = OntObjectHash(
binary=helpers.generate_bytearray(ont_constants.ONT_HASH_LEN))
tracked_blocks = []
self.cleanup_service.on_new_block_received(marked_block, prev_block)
self.transaction_service.track_seen_short_ids(marked_block, [])
for _ in range(self.block_confirmations_count - 1):
tracked_block = OntObjectHash(
binary=helpers.generate_bytearray(ont_constants.ONT_HASH_LEN))
self.transaction_service.track_seen_short_ids(tracked_block, [])
tracked_blocks.append(tracked_block)
unmarked_block = OntObjectHash(
binary=helpers.generate_bytearray(ont_constants.ONT_HASH_LEN))
self.assertIsNone(self.cleanup_service.last_confirmed_block)
self.cleanup_service.mark_blocks_and_request_cleanup(
[marked_block, *tracked_blocks])
self.assertEqual(marked_block,
self.cleanup_service.last_confirmed_block)
self.assertTrue(
self.cleanup_service.is_marked_for_cleanup(marked_block))
self.assertFalse(
self.cleanup_service.is_marked_for_cleanup(unmarked_block))
self.assertEqual(marked_block,
self.cleanup_service.last_confirmed_block)
msg = self.node.send_to_node_messages.pop(-1)
self.assertEqual((InventoryOntType.MSG_BLOCK.value, marked_block),
msg.inv_type())
def _test_mark_blocks_and_request_cleanup(self):
self.node.has_active_blockchain_peer = MagicMock(return_value=True)
self.cleanup_service._request_block = MagicMock()
marked_block = OntObjectHash(
binary=helpers.generate_bytearray(ont_constants.ONT_HASH_LEN))
prev_block = OntObjectHash(
binary=helpers.generate_bytearray(ont_constants.ONT_HASH_LEN))
tracked_blocks = []
self.cleanup_service.on_new_block_received(marked_block, prev_block)
self.transaction_service.track_seen_short_ids(marked_block, [])
for _ in range(self.block_confirmations_count - 1):
tracked_block = OntObjectHash(
binary=helpers.generate_bytearray(ont_constants.ONT_HASH_LEN))
self.transaction_service.track_seen_short_ids(tracked_block, [])
tracked_blocks.append(tracked_block)
unmarked_block = OntObjectHash(
binary=helpers.generate_bytearray(ont_constants.ONT_HASH_LEN))
self.assertIsNone(self.cleanup_service.last_confirmed_block)
self.cleanup_service.mark_blocks_and_request_cleanup(
[marked_block, *tracked_blocks])
self.assertEqual(marked_block,
self.cleanup_service.last_confirmed_block)
self.assertTrue(
self.cleanup_service.is_marked_for_cleanup(marked_block))
self.assertFalse(
self.cleanup_service.is_marked_for_cleanup(unmarked_block))
self.assertEqual(marked_block,
self.cleanup_service.last_confirmed_block)
self.cleanup_service._request_block.assert_called_once()
def test_propagate_block_to_network_unencrypted_block(self):
self.node.opts.encrypt_blocks = False
block_message = helpers.generate_bytearray(50)
block_info = BlockInfo(
Sha256Hash(helpers.generate_bytearray(crypto.SHA256_HASH_LEN)), [],
datetime.datetime.utcnow(), datetime.datetime.utcnow(), 0, 1,
helpers.generate_bytearray(crypto.SHA256_HASH_LEN),
helpers.generate_bytearray(crypto.SHA256_HASH_LEN), 0, 0, 0, [])
connection = MockConnection(
MockSocketConnection(1, self.node, ip_address=LOCALHOST,
port=9000), self.node)
self.neutrality_service.propagate_block_to_network(
block_message, connection, block_info)
self.assertEqual(1, len(self.node.broadcast_messages))
broadcast_message, connection_types = self.node.broadcast_messages[0]
# self.assertTrue(any(ConnectionType.RELAY_BLOCK & connection_type for connection_type in connection_types))
self.assertTrue(
all(ConnectionType.RELAY_BLOCK in connection_type
for connection_type in connection_types))
self.assertEqual(block_info.block_hash, broadcast_message.block_hash())
self.assertNotIn(block_info.block_hash,
self.node.in_progress_blocks._cache)
self.assertNotIn(broadcast_message.block_hash(),
self.neutrality_service._receipt_tracker)
def _test_process_tx_sync_message(self):
content_short_ids = []
tx_hashes = []
short_ids = []
contents = []
tx_count = 30
for i in range(tx_count):
tx_hash = Sha256Hash(binary=helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
tx_content = helpers.generate_bytearray(100 + i)
short_id1 = i * 2 + 1
short_id2 = short_id1 + 1
tx_short_id = TxContentShortIds(
tx_hash,
tx_content,
[short_id1, short_id2],
[TransactionFlag.NO_FLAGS, TransactionFlag.PAID_TX]
)
tx_hashes.append(tx_hash)
short_ids.append(short_id1)
short_ids.append(short_id2)
contents.append(tx_content)
content_short_ids.append(tx_short_id)
txs_sync_message = TxServiceSyncTxsMessage(1, txs_content_short_ids=content_short_ids)
result_items = self.transaction_service.process_tx_sync_message(txs_sync_message)
self.assertEqual(len(result_items), len(tx_hashes))
for item, tx_short_id in zip(result_items, txs_sync_message.txs_content_short_ids()):
transaction_key = self.transaction_service.get_transaction_key(item.hash)
self.assertEqual(item.hash, tx_short_id.tx_hash)
self.assertEqual(item.content_length, len(tx_short_id.tx_content))
self.assertEqual(2, len(item.short_ids))
self.assertEqual(item.short_ids[0], tx_short_id.short_ids[0])
self.assertEqual(item.short_ids[1], tx_short_id.short_ids[1])
self.assertEqual(len(item.transaction_flag_types), len(tx_short_id.short_id_flags))
self.assertEqual(item.transaction_flag_types[0], tx_short_id.short_id_flags[0])
self.assertEqual(item.transaction_flag_types[1], tx_short_id.short_id_flags[1])
tx_content = self.transaction_service.get_transaction_by_key(transaction_key)
self.assertEqual(len(tx_content), item.content_length)
saved_short_ids = self.transaction_service.get_short_ids_by_key(transaction_key)
self.assertEqual(len(saved_short_ids), len(item.short_ids))
for sid in item.short_ids:
self.assertIn(sid, saved_short_ids)
self.assertTrue(self.transaction_service.has_short_id(sid))
assign_time = self.transaction_service.get_short_id_assign_time(sid)
self.assertTrue(assign_time > 0)
def test_normal_frame(self):
cipher1, cipher2 = self.setup_ciphers()
dummy_msg_type = 1
dummy_payload = helpers.generate_bytearray(123)
dummy_protocol = 0
frames = frame_utils.get_frames(
dummy_msg_type, memoryview(dummy_payload), dummy_protocol,
eth_common_constants.DEFAULT_FRAME_SIZE)
input_buffer = InputBuffer()
for frame in frames:
encrypted_frame = cipher1.encrypt_frame(frame)
encrypted_frame_bytes = bytearray(
rlp_utils.str_to_bytes(encrypted_frame))
input_buffer.add_bytes(encrypted_frame_bytes)
# adding some dummy bytes but less than header size len
dummy_bytes_len = int(eth_common_constants.FRAME_HDR_TOTAL_LEN / 2)
input_buffer.add_bytes(helpers.generate_bytearray(dummy_bytes_len))
framed_input_buffer = FramedInputBuffer(cipher2)
is_full, msg_type = framed_input_buffer.peek_message(input_buffer)
self.assertTrue(is_full)
self.assertEqual(msg_type, dummy_msg_type)
message, full_msg_type = framed_input_buffer.get_full_message()
self.assertEqual(message, dummy_payload)
self.assertEqual(full_msg_type, dummy_msg_type)
self.assertEqual(input_buffer.length, dummy_bytes_len)
def test_broadcast_to_connection_type(self):
relay_all_conn = self._add_connection(0, 9000, ALL_NETWORK_NUM, ConnectionType.RELAY_ALL)
relay_block_conn = self._add_connection(1, 9001, ALL_NETWORK_NUM, ConnectionType.RELAY_BLOCK)
relay_transaction_conn = self._add_connection(2, 9002, ALL_NETWORK_NUM, ConnectionType.RELAY_TRANSACTION)
gateway_conn = self._add_connection(3, 9003, ALL_NETWORK_NUM, ConnectionType.EXTERNAL_GATEWAY)
block_message = BroadcastMessage(Sha256Hash(helpers.generate_hash()), ALL_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, False, helpers.generate_bytearray(250))
self.sut.broadcast(block_message, BroadcastOptions(connection_types=[ConnectionType.RELAY_BLOCK]))
tx_message = BroadcastMessage(Sha256Hash(helpers.generate_hash()), ALL_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, False, helpers.generate_bytearray(250))
self.sut.broadcast(tx_message, BroadcastOptions(connection_types=[ConnectionType.RELAY_TRANSACTION]))
gateway_message = BroadcastMessage(Sha256Hash(helpers.generate_hash()), ALL_NETWORK_NUM, "",
BroadcastMessageType.BLOCK, False, helpers.generate_bytearray(250))
self.sut.broadcast(gateway_message, BroadcastOptions(connection_types=[ConnectionType.GATEWAY]))
self.assertIn(block_message, relay_all_conn.enqueued_messages)
self.assertIn(block_message, relay_block_conn.enqueued_messages)
self.assertNotIn(block_message, relay_transaction_conn.enqueued_messages)
self.assertNotIn(block_message, gateway_conn.enqueued_messages)
self.assertIn(tx_message, relay_all_conn.enqueued_messages)
self.assertNotIn(tx_message, relay_block_conn.enqueued_messages)
self.assertIn(tx_message, relay_transaction_conn.enqueued_messages)
self.assertNotIn(tx_message, gateway_conn.enqueued_messages)
self.assertNotIn(gateway_message, relay_all_conn.enqueued_messages)
self.assertNotIn(gateway_message, relay_block_conn.enqueued_messages)
self.assertNotIn(gateway_message, relay_transaction_conn.enqueued_messages)
self.assertIn(gateway_message, gateway_conn.enqueued_messages)
def setUp(self):
opts = gateway_helpers.get_gateway_opts(8000,
include_default_ont_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = MockOntGatewayNode(opts)
self.node.neutrality_service = MagicMock()
self.connection = OntNodeConnection(
MockSocketConnection(1,
node=self.node,
ip_address=LOCALHOST,
port=123), self.node)
gateway_helpers.add_blockchain_peer(self.node, self.connection)
self.tx_hash = OntObjectHash(buf=helpers.generate_bytearray(32),
length=ONT_HASH_LEN)
self.block_hash = OntObjectHash(buf=helpers.generate_bytearray(32),
length=ONT_HASH_LEN)
self.sut = OntNodeConnectionProtocol(self.connection)
while self.connection.outputbuf.length > 0:
initial_bytes = self.connection.get_bytes_to_send()
self.connection.advance_sent_bytes(len(initial_bytes))
def _test_mark_blocks_and_request_cleanup(self):
marked_block = Sha256Hash(
binary=helpers.generate_bytearray(SHA256_HASH_LEN))
prev_block = Sha256Hash(
binary=helpers.generate_bytearray(SHA256_HASH_LEN))
tracked_blocks = []
self.cleanup_service.on_new_block_received(marked_block, prev_block)
self.transaction_service.track_seen_short_ids(marked_block, [])
for _ in range(self.block_confirmations_count - 1):
tracked_block = Sha256Hash(
binary=helpers.generate_bytearray(SHA256_HASH_LEN))
self.transaction_service.track_seen_short_ids(tracked_block, [])
tracked_blocks.append(tracked_block)
unmarked_block = Sha256Hash(
binary=helpers.generate_bytearray(SHA256_HASH_LEN))
self.assertIsNone(self.cleanup_service.last_confirmed_block)
self.cleanup_service.mark_blocks_and_request_cleanup(
[marked_block, *tracked_blocks])
self.assertEqual(marked_block,
self.cleanup_service.last_confirmed_block)
self.assertTrue(
self.cleanup_service.is_marked_for_cleanup(marked_block))
self.assertFalse(
self.cleanup_service.is_marked_for_cleanup(unmarked_block))
self.assertEqual(marked_block,
self.cleanup_service.last_confirmed_block)
def test_set_contents(self):
transaction_hash = Sha256Hash(
helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
transaction_key = self.transaction_service.get_transaction_key(
transaction_hash)
tx_contents = memoryview(helpers.generate_bytearray(500))
self.assertFalse(
self.transaction_service.has_transaction_contents_by_key(
transaction_key))
self.transaction_service.set_transaction_contents_by_key(
transaction_key, tx_contents)
self.assertTrue(
self.transaction_service.has_transaction_contents_by_key(
transaction_key))
saved_contents = self.transaction_service.get_transaction_by_key(
transaction_key)
self.assertEqual(convert.bytes_to_hex(tx_contents),
convert.bytes_to_hex(saved_contents.tobytes()))
self.assertEqual(len(tx_contents),
self.transaction_service._total_tx_contents_size)
new_content = memoryview(helpers.generate_bytearray(750))
self.transaction_service.set_transaction_contents_by_key(
transaction_key, new_content)
saved_contents = self.transaction_service.get_transaction_by_key(
transaction_key)
self.assertEqual(convert.bytes_to_hex(tx_contents),
convert.bytes_to_hex(saved_contents.tobytes()))
self.assertEqual(len(new_content),
self.transaction_service._total_tx_contents_size)
def test_on_bytes_sent(self):
self.connection.outputbuf.output_msgs.append(helpers.generate_bytearray(200))
self.connection.outputbuf.output_msgs.append(helpers.generate_bytearray(200))
self.node.connection_pool.add(self.fileno, self.ip, self.port, self.connection)
advance_by = 8
self.node.on_bytes_sent(self.fileno, advance_by)
self.assertEqual(advance_by, self.connection.outputbuf.index)
def test_parse_message_success_all_types(self):
# TODO: pull these numbers into constants, along with all the BTC messages
self.create_message_successfully(self.VERSION_BTC_MESSAGE,
VersionBtcMessage)
self.create_message_successfully(VerAckBtcMessage(self.MAGIC),
VerAckBtcMessage)
self.create_message_successfully(PingBtcMessage(self.MAGIC),
PingBtcMessage)
self.create_message_successfully(PongBtcMessage(self.MAGIC, 123),
PongBtcMessage)
self.create_message_successfully(GetAddrBtcMessage(self.MAGIC),
GetAddrBtcMessage)
self.create_message_successfully(
AddrBtcMessage(self.MAGIC,
[(int(time.time()), "127.0.0.1", 8000)]),
AddrBtcMessage)
inv_vector = [(1, self.HASH), (2, self.HASH)]
self.create_message_successfully(InvBtcMessage(self.MAGIC, inv_vector),
InvBtcMessage)
self.create_message_successfully(
GetDataBtcMessage(self.MAGIC, inv_vector), GetDataBtcMessage)
self.create_message_successfully(
NotFoundBtcMessage(self.MAGIC, inv_vector), NotFoundBtcMessage)
hashes = [self.HASH, self.HASH]
self.create_message_successfully(
GetHeadersBtcMessage(self.MAGIC, self.VERSION, hashes, self.HASH),
GetHeadersBtcMessage)
self.create_message_successfully(
GetBlocksBtcMessage(self.MAGIC, self.VERSION, hashes, self.HASH),
GetBlocksBtcMessage)
self.create_message_successfully(
TxBtcMessage(self.MAGIC, self.VERSION, [], [], 0), TxBtcMessage)
txs = [TxIn(buf=bytearray(10), length=10, off=0).rawbytes()] * 5
self.create_message_successfully(
BlockBtcMessage(self.MAGIC, self.VERSION, self.HASH, self.HASH, 0,
0, 0, txs), BlockBtcMessage)
self.create_message_successfully(
HeadersBtcMessage(self.MAGIC,
[helpers.generate_bytearray(81)] * 2),
HeadersBtcMessage)
self.create_message_successfully(
RejectBtcMessage(self.MAGIC, b"a message",
RejectBtcMessage.REJECT_MALFORMED, b"test break",
helpers.generate_bytearray(10)), RejectBtcMessage)
self.create_message_successfully(SendHeadersBtcMessage(self.MAGIC),
SendHeadersBtcMessage)
self.create_message_successfully(
FeeFilterBtcMessage(self.MAGIC, fee_rate=100), FeeFilterBtcMessage)
self.create_message_successfully(
BtcMessage(self.MAGIC, b'xversion', 0, bytearray(30)),
XversionBtcMessage)
def test_string_xor(self):
str1 = helpers.generate_bytearray(111)
str2 = helpers.generate_bytearray(111)
sxor = crypto_utils.string_xor(str1, str2)
self.assertIsNotNone(sxor)
self.assertEqual(len(sxor), len(str1))
def test_sign_and_verify__invalid(self):
msg = helpers.generate_bytearray(111)
msg_hash = eth_common_utils.keccak_hash(msg)
signature = self._eccx.sign(msg_hash)
other_private_key = crypto_utils.make_private_key(helpers.generate_bytearray(222))
another_eccx = ECCx(raw_private_key=other_private_key)
self.assertFalse(another_eccx.verify(signature, msg_hash))
def test_sha3(self):
dummy_msg1 = helpers.generate_bytearray(111)
dummy_msg2 = helpers.generate_bytearray(1111)
sha1 = eth_common_utils.keccak_hash(dummy_msg1)
sha2 = eth_common_utils.keccak_hash(dummy_msg2)
self.assertEqual(len(sha1), eth_common_constants.SHA3_LEN_BYTES)
self.assertEqual(len(sha2), eth_common_constants.SHA3_LEN_BYTES)
self.assertNotEqual(sha1, sha2)
def broadcast_key_pair(short_ids=None, network_num=0):
if short_ids is None:
short_ids = [1, 10, 99, 187]
broadcast_message_hash = Sha256Hash(helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
broadcast_message_bytes = bytearray(constants.UL_ULL_SIZE_IN_BYTES)
broadcast_message_bytes.extend(helpers.generate_bytearray(500))
struct.pack_into("<Q", broadcast_message_bytes, 0, len(broadcast_message_bytes))
broadcast_message_bytes.extend(compact_block_short_ids_serializer.serialize_short_ids_into_bytes(short_ids))
key_bytes, enc_broadcast_message_bytes = crypto.symmetric_encrypt(bytes(broadcast_message_bytes))
broadcast_message = BroadcastMessage(broadcast_message_hash, network_num, "", True, enc_broadcast_message_bytes)
key_message = KeyMessage(broadcast_message_hash, network_num, "", key_bytes)
return broadcast_message, key_message
def test_sign_and_verify_signature__valid_signature(self):
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
public_key = crypto_utils.private_to_public_key(dummy_private_key)
# generate random bytes
msg = helpers.generate_bytearray(222)
msg_hash = eth_common_utils.keccak_hash(msg)
signature = crypto_utils.sign(msg_hash, dummy_private_key)
self.assertTrue(
crypto_utils.verify_signature(public_key, signature, msg_hash))
def test_place_hold(self):
hash1 = Sha256Hash(helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
hash2 = Sha256Hash(helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
self.sut.place_hold(hash1, self.dummy_connection)
self.sut.place_hold(hash2, self.dummy_connection)
self.assertEqual(2, len(self.sut._holds.contents))
self.assertEqual(2, len(self.node.broadcast_messages))
self.assertEqual(BlockHoldingMessage(hash1, network_num=1),
self.node.broadcast_messages[0][0])
self.assertEqual(BlockHoldingMessage(hash2, network_num=1),
self.node.broadcast_messages[1][0])
def _test_track_short_ids_seen_in_block(self):
short_ids = [1, 2, 3, 4, 5]
transaction_hashes = list(map(crypto.double_sha256, map(bytes, short_ids)))
transaction_contents = list(map(crypto.double_sha256, transaction_hashes))
for i, short_id in enumerate(short_ids):
transaction_key = self.transaction_service.get_transaction_key(transaction_hashes[i])
self.transaction_service._tx_cache_key_to_contents[transaction_key.transaction_cache_key] = \
transaction_contents[i]
self.transaction_service.assign_short_id_by_key(transaction_key, short_id)
self.transaction_service.set_final_tx_confirmations_count(7)
# 1st block with short ids arrives
block_hash = bytearray(helpers.generate_bytearray(32))
self.transaction_service.track_seen_short_ids(Sha256Hash(block_hash), [1])
self._verify_txs_in_tx_service([1, 2, 3, 4, 5], [])
# 2nd block with short ids arrives
block_hash = bytearray(helpers.generate_bytearray(32))
self.transaction_service.track_seen_short_ids(Sha256Hash(block_hash), [2])
self._verify_txs_in_tx_service([1, 2, 3, 4, 5], [])
# 3rd block with short ids arrives
block_hash = bytearray(helpers.generate_bytearray(32))
self.transaction_service.track_seen_short_ids(Sha256Hash(block_hash), [3, 4])
self._verify_txs_in_tx_service([1, 2, 3, 4, 5], [])
# 4th block with short ids arrives
block_hash = bytearray(helpers.generate_bytearray(32))
self.transaction_service.track_seen_short_ids(Sha256Hash(block_hash), [])
self._verify_txs_in_tx_service([1, 2, 3, 4, 5], [])
# 5th block with short ids arrives
block_hash = bytearray(helpers.generate_bytearray(32))
self.transaction_service.track_seen_short_ids(Sha256Hash(block_hash), [])
self._verify_txs_in_tx_service([1, 2, 3, 4, 5], [])
# 6th block with short ids arrives
block_hash = bytearray(helpers.generate_bytearray(32))
self.transaction_service.track_seen_short_ids(Sha256Hash(block_hash), [])
self._verify_txs_in_tx_service([1, 2, 3, 4, 5], [])
# 7th block with short ids arrives
block_hash = bytearray(helpers.generate_bytearray(32))
self.transaction_service.track_seen_short_ids(Sha256Hash(block_hash), [])
self._verify_txs_in_tx_service([2, 3, 4], [0, 1])
# 8th block with short ids arrives
block_hash = bytearray(helpers.generate_bytearray(32))
self.transaction_service.track_seen_short_ids(Sha256Hash(block_hash), [])
self._verify_txs_in_tx_service([3, 4], [0, 1, 2])
# 9th block with short ids arrives
block_hash = bytearray(helpers.generate_bytearray(32))
self.transaction_service.track_seen_short_ids(Sha256Hash(block_hash), [])
self._verify_txs_in_tx_service([], [0, 1, 2, 3, 4])
def _add_transactions(self, tx_count, tx_size, short_id_offset=0):
transactions = []
for i in range(int(tx_count)):
tx_hash = Sha256Hash(binary=helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
tx_content = helpers.generate_bytearray(tx_size)
short_id = short_id_offset + i + 1
self.transaction_service.set_transaction_contents(tx_hash, tx_content)
self.transaction_service.assign_short_id(tx_hash, short_id)
transactions.append(TransactionInfo(tx_hash, tx_content, short_id))
return transactions
def test_recover_public_key(self):
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
public_key = crypto_utils.private_to_public_key(dummy_private_key)
msg = helpers.generate_bytearray(222)
msg_hash = eth_common_utils.keccak_hash(msg)
signature = crypto_utils.sign(msg_hash, dummy_private_key)
recovered_pub_key = crypto_utils.recover_public_key(
msg_hash, signature)
self.assertEqual(recovered_pub_key, public_key)
def test_safe_empty_buffering(self):
messages = [
helpers.generate_bytearray(10),
helpers.generate_bytearray(10)
]
for message in messages:
self.output_buffer.enqueue_msgbytes(message)
self.assertEqual(20, len(self.output_buffer))
self.assertEqual(OutputBuffer.EMPTY, self.output_buffer.get_buffer())
self.output_buffer.safe_empty()
self.assertEqual(0, len(self.output_buffer))
self.assertEqual(OutputBuffer.EMPTY, self.output_buffer.get_buffer())
def test_safe_empty(self):
self.output_buffer = OutputBuffer(enable_buffering=False)
messages = [
helpers.generate_bytearray(10),
helpers.generate_bytearray(10)
]
for message in messages:
self.output_buffer.enqueue_msgbytes(message)
self.output_buffer.advance_buffer(5)
self.assertEqual(15, len(self.output_buffer))
self.output_buffer.safe_empty()
self.assertEqual(5, len(self.output_buffer))
def test_place_hold_duplicates(self):
hash1 = Sha256Hash(helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
hash2 = Sha256Hash(helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
self.sut.place_hold(hash1, self.dummy_connection)
time.time = MagicMock(return_value=time.time() + 5)
self.sut.place_hold(hash1, self.dummy_connection)
self.sut.place_hold(hash1, self.dummy_connection)
self.sut.place_hold(hash2, self.dummy_connection)
self.assertEqual(2, len(self.sut._holds.contents))
hold1 = self.sut._holds.contents[hash1]
hold2 = self.sut._holds.contents[hash2]
self.assertTrue(hold2.hold_message_time - hold1.hold_message_time >= 5)
def test_peek_network_num(self):
network_num = 12345
hash_bytes = helpers.generate_bytearray(SHA256_HASH_LEN)
msg_hash = Sha256Hash(hash_bytes)
block_bytes = helpers.generate_bytearray(1234)
broadcast_msg = BroadcastMessage(message_hash=msg_hash, network_num=network_num, source_id="", blob=block_bytes)
msg_bytes = broadcast_msg.rawbytes()
input_buffer = InputBuffer()
input_buffer.add_bytes(msg_bytes)
peeked_network_num = BroadcastMessage.peek_network_num(input_buffer)
self.assertEqual(network_num, peeked_network_num)
class MockMessageConverter(AbstractMessageConverter):
PREV_BLOCK = Sha256Hash(helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
def tx_to_bx_txs(self, tx_msg, network_num, quota_type: Optional[QuotaType] = None,
min_tx_network_fee=0):
return [(tx_msg, tx_msg.tx_hash(), tx_msg.tx_val(), quota_type)]
def bx_tx_to_tx(self, bx_tx_msg):
return bx_tx_msg
def block_to_bx_block(
self, block_msg, tx_service, enable_block_compression: bool, min_tx_age_seconds: float
) -> Tuple[memoryview, BlockInfo]:
return block_msg.rawbytes(), \
BlockInfo(convert.bytes_to_hex(self.PREV_BLOCK.binary), [], datetime.datetime.utcnow(),
datetime.datetime.utcnow(), 0, 0, None, None, 0, 0, 0, [])
def bx_block_to_block(self, bx_block_msg, tx_service) -> BlockDecompressionResult:
block_message = MockBlockMessage(buf=bx_block_msg)
return BlockDecompressionResult(block_message, block_message.block_hash(), [], [])
def bdn_tx_to_bx_tx(
self,
raw_tx: Union[bytes, bytearray, memoryview],
network_num: int,
quota_type: Optional[QuotaType] = None
) -> TxMessage:
return TxMessage(Sha256Hash(crypto.double_sha256(raw_tx)), network_num, tx_val=raw_tx)
def test_is_valid_control_flag__valid(self):
message_len = 1000
message_bytes = bytearray(message_len)
message_bytes[:constants.
STARTING_SEQUENCE_BYTES_LEN] = constants.STARTING_SEQUENCE_BYTES
message_bytes[-1] = BloxrouteMessageControlFlags.VALID
input_buffer = InputBuffer()
input_buffer.add_bytes(message_bytes)
# adding random bytes to the end of intput buffer
input_buffer.add_bytes(helpers.generate_bytearray(10))
payload_len = message_len - constants.STARTING_SEQUENCE_BYTES_LEN - constants.BX_HDR_COMMON_OFF
# valid payload len
self.message_validator.validate(
True, BloxrouteMessageType.TRANSACTION,
constants.STARTING_SEQUENCE_BYTES_LEN +
constants.BX_HDR_COMMON_OFF, payload_len, input_buffer)
# invalid payload len - too long
self.assertRaises(
MessageValidationError, self.message_validator.validate, True,
BloxrouteMessageType.TRANSACTION,
constants.STARTING_SEQUENCE_BYTES_LEN +
constants.BX_HDR_COMMON_OFF, message_len, input_buffer)
async def test_transaction_status(self):
time.time = MagicMock(return_value=time.time())
expected_assignment_time = datetime.datetime.fromtimestamp(
time.time()).isoformat()
short_id = 123
transaction_hash = helpers.generate_object_hash()
transaction_contents = helpers.generate_bytearray(250)
tx_service = self.gateway_node.get_tx_service()
transaction_key = tx_service.get_transaction_key(transaction_hash)
tx_service.set_transaction_contents_by_key(transaction_key,
transaction_contents)
tx_service.assign_short_id_by_key(transaction_key, short_id)
result = await self.request(
BxJsonRpcRequest("7", RpcRequestType.TX_STATUS, {
"transaction_hash":
convert.bytes_to_hex(transaction_hash.binary)
}))
self.assertEqual("7", result.id)
self.assertIsNone(result.error)
self.assertEqual(
{
"status": "assigned short ID",
"short_ids": [123],
"assignment_time": expected_assignment_time
}, result.result)
def test_sign_and_verify__valid(self):
msg = helpers.generate_bytearray(111)
msg_hash = eth_common_utils.keccak_hash(msg)
signature = self._eccx.sign(msg_hash)
self.assertTrue(self._eccx.verify(signature, msg_hash))
def key_message(self) -> KeyMessage:
return KeyMessage(
helpers.generate_object_hash(),
self.NETWORK_NUMBER,
self.NODE_ID,
helpers.generate_bytearray(32),
)
def test_assign_short_id(self):
transaction_hash = Sha256Hash(
helpers.generate_bytearray(crypto.SHA256_HASH_LEN))
transaction_key = self.transaction_service.get_transaction_key(
transaction_hash)
short_id1 = 100
self.assertFalse(self.transaction_service.has_short_id(short_id1))
self.assertFalse(
self.transaction_service.has_transaction_contents_by_key(
transaction_key))
self.transaction_service.assign_short_id(transaction_hash, short_id1)
self.assertTrue(self.transaction_service.has_short_id(short_id1))
self.assertFalse(
self.transaction_service.has_transaction_contents_by_key(
transaction_key))
short_id2 = 200
self.transaction_service.assign_short_id_by_key(
transaction_key, short_id2)
self.assertTrue(self.transaction_service.has_short_id(short_id2))
short_ids = self.transaction_service.get_short_ids_by_key(
transaction_key)
self.assertEqual(2, len(short_ids))
self.assertTrue(short_id1 in short_ids)
self.assertTrue(short_id2 in short_ids)
