def setUp(self):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000,
include_default_btc_args=True,
include_default_eth_args=True))
self.relay_connection = AbstractRelayConnection(
MockSocketConnection(node=self.node,
ip_address="127.0.0.1",
port=12345), self.node)
self.blockchain_connection = EthBaseConnection(
MockSocketConnection(node=self.node,
ip_address="127.0.0.1",
port=12345), self.node)
self.node.message_converter = converter_factory.create_eth_message_converter(
self.node.opts)
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
dummy_public_key = crypto_utils.private_to_public_key(
dummy_private_key)
self.blockchain_connection_protocol = EthNodeConnectionProtocol(
self.blockchain_connection, True, dummy_private_key,
dummy_public_key)
self.blockchain_connection.network_num = 0
self.blockchain_connection_protocol.publish_transaction = MagicMock()
self.relay_connection.state = ConnectionState.INITIALIZED
gateway_transaction_stats_service.set_node(self.node)
def __init__(self, opts, node_ssl_service: NodeSSLService) -> None:
super(EthGatewayNode, self).__init__(
opts, node_ssl_service,
eth_common_constants.TRACKED_BLOCK_CLEANUP_INTERVAL_S)
self._node_public_key = None
self._remote_public_key = None
if opts.node_public_key is not None:
self._node_public_key = convert.hex_to_bytes(opts.node_public_key)
elif opts.blockchain_peers is None:
raise RuntimeError(
"128 digit public key must be included with command-line specified blockchain peer."
)
if opts.remote_blockchain_peer is not None:
if opts.remote_public_key is None:
raise RuntimeError(
"128 digit public key must be included with command-line specified remote blockchain peer."
)
else:
self._remote_public_key = convert.hex_to_bytes(
opts.remote_public_key)
self.block_processing_service: EthBlockProcessingService = EthBlockProcessingService(
self)
self.block_queuing_service: EthBlockQueuingService = EthBlockQueuingService(
self)
# List of know total difficulties, tuples of values (block hash, total difficulty)
self._last_known_difficulties = deque(
maxlen=eth_common_constants.LAST_KNOWN_TOTAL_DIFFICULTIES_MAX_COUNT
)
# queue of the block hashes requested from remote blockchain node during sync
self._requested_remote_blocks_queue = deque()
# number of remote block requests to skip in case if requests and responses got out of sync
self._skip_remote_block_requests_stats_count = 0
self.init_eth_gateway_stat_logging()
self.init_eth_on_block_feed_stat_logging()
self.message_converter = converter_factory.create_eth_message_converter(
self.opts)
self.eth_ws_proxy_publisher = EthWsProxyPublisher(
opts.eth_ws_uri, self.feed_manager, self._tx_service, self)
if self.opts.ws and not self.opts.eth_ws_uri:
logger.warning(log_messages.ETH_WS_SUBSCRIBER_NOT_STARTED)
self.average_block_gas_price = RunningAverage(
gateway_constants.ETH_GAS_RUNNING_AVERAGE_SIZE)
self.min_tx_from_node_gas_price = IntervalMinimum(
gateway_constants.ETH_MIN_GAS_INTERVAL_S, self.alarm_queue)
logger.info("Gateway enode url: {}", self.get_enode())
def init(self, use_extensions: bool):
opts = Namespace()
opts.use_extensions = use_extensions
opts.enable_eth_extensions = use_extensions # TODO remove
opts.import_extensions = use_extensions
opts.tx_mem_pool_bucket_size = DEFAULT_TX_MEM_POOL_BUCKET_SIZE
eth_message_converter = converter_factory.create_eth_message_converter(opts=opts)
if use_extensions:
helpers.set_extensions_parallelism()
tx_service = ExtensionTransactionService(MockNode(
gateway_helpers.get_gateway_opts(8999)), 0)
else:
tx_service = TransactionService(MockNode(
gateway_helpers.get_gateway_opts(8999)), 0)
return tx_service, eth_message_converter
def setUp(self):
self.eth_message_converter: EthAbstractMessageConverter = converter_factory.create_eth_message_converter(
gateway_helpers.get_gateway_opts(8000)
)
self.tx_service = ExtensionTransactionService(MockNode(gateway_helpers.get_gateway_opts(8000)), 0)
self.test_network_num = 12345
def setUp(self):
self.node = MockGatewayNode(gateway_helpers.get_gateway_opts(
8000, include_default_eth_args=True, use_extensions=True),
block_queueing_cls=MagicMock())
self.node.message_converter = converter_factory.create_eth_message_converter(
self.node.opts)
self.node.block_processing_service = BlockProcessingService(self.node)
is_handshake_initiator = True
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
dummy_public_key = crypto_utils.private_to_public_key(
dummy_private_key)
rlpx_cipher = RLPxCipher(is_handshake_initiator, dummy_private_key,
dummy_public_key)
node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE,
MagicMock())
local_ip = "127.0.0.1"
eth_port = 30303
eth_opts = gateway_helpers.get_gateway_opts(
1234,
include_default_eth_args=True,
blockchain_address=(local_ip, eth_port),
pub_key=convert.bytes_to_hex(dummy_public_key))
self.eth_node = EthGatewayNode(eth_opts, node_ssl_service)
self.blockchain_connection = EthNodeConnection(
MockSocketConnection(1,
node=self.node,
ip_address=local_ip,
port=30303), self.node)
self.blockchain_connection.on_connection_established()
self.node.connection_pool.add(19, local_ip, eth_port,
self.blockchain_connection)
self.blockchain_connection_1 = EthNodeConnection(
MockSocketConnection(1,
node=self.node,
ip_address=local_ip,
port=333), self.node)
self.blockchain_connection_1.on_connection_established()
self.node.mock_add_blockchain_peer(self.blockchain_connection_1)
self.node_1_endpoint = IpEndpoint(local_ip, 333)
self.node.connection_pool.add(20, self.node_1_endpoint.ip_address,
self.node_1_endpoint.port,
self.blockchain_connection_1)
self.blockchain_connection_2 = EthNodeConnection(
MockSocketConnection(1,
node=self.node,
ip_address=local_ip,
port=444), self.node)
self.blockchain_connection_2.on_connection_established()
self.node.mock_add_blockchain_peer(self.blockchain_connection_2)
self.node_2_endpoint = IpEndpoint(local_ip, 444)
self.node.connection_pool.add(21, self.node_2_endpoint.ip_address,
self.node_2_endpoint.port,
self.blockchain_connection_2)
self.blockchain_connection_1.network_num = 0
self.tx_blockchain_connection_protocol = EthNodeConnectionProtocol(
self.blockchain_connection_1, is_handshake_initiator, rlpx_cipher)
self.block_blockchain_connection_protocol = EthNodeConnectionProtocol(
self.blockchain_connection_1, is_handshake_initiator, rlpx_cipher)
self.tx_blockchain_connection_protocol.publish_transaction = MagicMock(
)
self.block_blockchain_connection_protocol.publish_transaction = MagicMock(
)
self.tx_blockchain_connection_protocol_2 = EthNodeConnectionProtocol(
self.blockchain_connection_2, is_handshake_initiator, rlpx_cipher)
self.block_blockchain_connection_protocol_2 = EthNodeConnectionProtocol(
self.blockchain_connection_2, is_handshake_initiator, rlpx_cipher)
self.tx_blockchain_connection_protocol_2.publish_transaction = MagicMock(
)
self.block_blockchain_connection_protocol_2.publish_transaction = MagicMock(
)
self.relay_connection = AbstractRelayConnection(
MockSocketConnection(1,
node=self.node,
ip_address=local_ip,
port=12345), self.node)
self.relay_connection.state = ConnectionState.INITIALIZED
gateway_bdn_performance_stats_service.set_node(self.node)
self.node.account_id = "12345"
