add support for TON collectors

Author: JooKop

src/collectors.py

@@ -548,3 +548,58 @@ def client_version(self):
     def latency(self):
         """Returns connection latency."""
         return self.interface.latest_query_latency
+
+class TonCollector():
+    """A collector to fetch information about Ton endpoints."""
+
+    def __init__(self, url, labels, chain_id, **client_parameters):
+
+        self.labels = labels
+        self.chain_id = chain_id
+        self.interface = HttpsInterface(url.rstrip("/") + "/jsonRPC", client_parameters.get('open_timeout'),
+                                        client_parameters.get('ping_timeout'))
+        self._logger_metadata = {
+            'component': 'TonCollector',
+            'url': strip_url(url)
+        }
+        self.block_height_payload = {
+            'jsonrpc': '2.0',
+            'method': "getMasterchainInfo",
+            'id': 1
+        }
+        self.consensus_block_height_payload = {
+            'jsonrpc': '2.0',
+            'method': "getConsensusBlock",
+            'id': 1
+        }
+
+    def alive(self):
+        """Returns true if endpoint is alive, false if not."""
+        # Run cached query because we can also fetch block height from this
+        # later on. This will save us an RPC call per run.
+        return self.interface.cached_json_rpc_post(
+            self.block_height_payload) is not None
+
+    def block_height(self):
+        """Returns latest block height."""
+        result = self.interface.cached_json_rpc_post(self.block_height_payload)
+        if result is None:
+            raise ValueError("No response received from TON endpoint")
+        block_height = result.get('last', {}).get('seqno', None)
+        if block_height is not None:
+            return block_height
+        raise ValueError(f"Invalid block height result: {result}")
+
+    def finalized_block_height(self):
+        """Runs a query to return consensus block height"""
+        result = self.interface.json_rpc_post(self.consensus_block_height_payload)
+        if result is None:
+            raise ValueError("No response received from TON endpoint")
+        consensus_block = result.get('consensus_block', None)
+        if consensus_block is not None:
+            return consensus_block
+        raise ValueError(f"Invalid consensus block height result: {result}")
+
+    def latency(self):
+        """Returns connection latency."""
+        return self.interface.latest_query_latency

src/configuration.py

@@ -45,7 +45,7 @@ def endpoints(self):
     def _load_configuration(self):
         supported_collectors = ('evm', 'evmhttp', 'cardano', 'conflux', 'solana',
                                 'bitcoin', 'doge', 'filecoin', 'starknet', 'aptos',
-                                'tron', 'xrpl')
+                                'tron', 'xrpl', 'ton')
 
         configuration_schema = Schema({
             'blockchain':

src/registries.py

@@ -90,6 +90,8 @@ def get_collector_registry(self) -> list:
                     collector = collectors.AptosCollector
                 case "xrpl", "xrpl":
                     collector = collectors.XRPLCollector
+                case "ton", "ton":
+                    collector = collectors.TonCollector
                 case "evmhttp", other: # pylint: disable=unused-variable
                     collector = collectors.EvmHttpCollector
                 case "evm", other:  # pylint: disable=unused-variable

src/test_collectors.py

@@ -961,3 +961,101 @@ def test_latency(self):
         """Tests that the latency is obtained from the interface based on latest_query_latency"""
         self.mocked_connection.return_value.latest_query_latency = 0.123
         self.assertEqual(0.123, self.xrpl_collector.latency())
+
+
+class TestTonCollector(TestCase):
+    """Tests the TON collector class"""
+
+    def setUp(self):
+        self.url = "https://test.com"
+        self.labels = ["dummy", "labels"]
+        self.chain_id = 123
+        self.open_timeout = 8
+        self.ping_timeout = 9
+        self.client_params = {
+            "open_timeout": self.open_timeout, "ping_timeout": self.ping_timeout}
+        self.block_height_payload = {
+            'jsonrpc': '2.0',
+            'method': "getMasterchainInfo",
+            'id': 1
+        }
+        self.consensus_block_height_payload = {
+            'jsonrpc': '2.0',
+            'method': "getConsensusBlock",
+            'id': 1
+        }
+        with mock.patch('collectors.HttpsInterface') as mocked_connection:
+            self.ton_collector = collectors.TonCollector(
+                self.url, self.labels, self.chain_id, **self.client_params)
+            self.mocked_connection = mocked_connection
+
+    def test_logger_metadata(self):
+        """Validate logger metadata. Makes sure url is stripped by helpers.strip_url function."""
+        expected_metadata = {
+            'component': 'TonCollector', 'url': 'test.com'}
+        self.assertEqual(expected_metadata,
+                         self.ton_collector._logger_metadata)
+
+    def test_connection_created(self):
+        """Tests that the ton collector calls the https interface with the correct args"""
+        self.mocked_connection.assert_called_once_with(
+            self.url + "/jsonRPC", self.open_timeout, self.ping_timeout)
+
+    def test_interface_attribute_exists(self):
+        """Tests that the interface attribute exists.
+        May be used by external calls to access objects such as the interface cache"""
+        self.assertTrue(hasattr(self.ton_collector, 'interface'))
+
+    def test_alive_true(self):
+        """Tests the alive function returns true when json_rpc_post returns valid result"""
+        self.mocked_connection.return_value.cached_json_rpc_post.return_value = {"last": {"seqno": 123}}
+        self.assertTrue(self.ton_collector.alive())
+
+    def test_alive_false(self):
+        """Tests the alive function returns false when json_rpc_post returns None"""
+        self.mocked_connection.return_value.cached_json_rpc_post.return_value = None
+        self.assertFalse(self.ton_collector.alive())
+
+    def test_block_height_success(self):
+        """Tests block_height method returns correct value"""
+        expected_height = 12345
+        self.mocked_connection.return_value.cached_json_rpc_post.return_value = {
+            "last": {"seqno": expected_height}}
+        result = self.ton_collector.block_height()
+        self.assertEqual(expected_height, result)
+
+    def test_block_height_none_response(self):
+        """Tests block_height method raises ValueError when response is None"""
+        self.mocked_connection.return_value.cached_json_rpc_post.return_value = None
+        with self.assertRaises(ValueError) as context:
+            self.ton_collector.block_height()
+        self.assertIn("No response received from TON endpoint", str(context.exception))
+
+    def test_block_height_invalid_response(self):
+        """Tests block_height method raises ValueError when response is invalid"""
+        self.mocked_connection.return_value.cached_json_rpc_post.return_value = {"invalid": "data"}
+        with self.assertRaises(ValueError) as context:
+            self.ton_collector.block_height()
+        self.assertIn("Invalid block height result", str(context.exception))
+
+    def test_finalized_block_height_success(self):
+        """Tests finalized_block_height method returns correct value"""
+        expected_height = 12345
+        self.mocked_connection.return_value.cached_json_rpc_post.return_value = {
+            "consensus_block": expected_height}
+        result = self.ton_collector.finalized_block_height()
+        self.assertEqual(expected_height, result)
+
+    def test_finalized_block_height_none_response(self):
+        """Tests finalized_block_height method raises ValueError when response is None"""
+        self.mocked_connection.return_value.cached_json_rpc_post.return_value = None
+        with self.assertRaises(ValueError) as context:
+            self.ton_collector.finalized_block_height()
+        self.assertIn("No response received from TON endpoint", str(context.exception))
+
+    def test_latency(self):
+        """Tests latency method returns interface latency"""
+        expected_latency = 0.123
+        self.mocked_connection.return_value.latest_query_latency = expected_latency
+        result = self.ton_collector.latency()
+        self.assertEqual(expected_latency, result)