nemtus-symbol-lightapi 0.0.9__tar.gz

nemtus_symbol_lightapi-0.0.9/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: nemtus-symbol-lightapi
+Version: 0.0.9
+Summary: Symbol Light API (NEMTUS mirror of upstream symbol-lightapi; import module: symbollightapi)
+Home-page: https://github.com/nemtus/symbol-product/tree/dev/lightapi/python
+Author: NEMTUS
+Author-email: info@nemtus.com
+License: MIT
+Keywords: symbol,symbollightapi,lightapi,Symbol Light API,nemtus
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp~=3.14.0
+Requires-Dist: aiolimiter~=1.2.1
+Requires-Dist: nemtus-symbol-sdk~=3.3.2
+Requires-Dist: zenlog~=1.1
+
+# Python Light API
+
+Provides partial Python wrappers for calling NEM and Symbol API functions.
+
+Only a subset of APIs are currently supported.
+
+PRs are accepted for extending the set of APIs.

nemtus_symbol_lightapi-0.0.9/README.md

@@ -0,0 +1,7 @@
+# Python Light API
+
+Provides partial Python wrappers for calling NEM and Symbol API functions.
+
+Only a subset of APIs are currently supported.
+
+PRs are accepted for extending the set of APIs.

nemtus_symbol_lightapi-0.0.9/cffi_src/openssl_build.py

@@ -0,0 +1,125 @@
+import os
+from pathlib import Path
+
+from cffi import FFI
+
+ffi_builder = FFI()
+
+# if specified, add openssl to the include path
+include_dirs = []
+library_dirs = []
+openssl_root_dir = os.environ.get('OPENSSL_ROOT_DIR', None)
+if openssl_root_dir:
+	include_dirs += [Path(openssl_root_dir) / 'include']
+	library_dirs += [str(Path(openssl_root_dir) / 'lib')]
+
+# build '_openssl_symbol' module and include openssl headers
+ffi_builder.set_source(
+	'_openssl_symbol',
+	r'''
+		#include <openssl/ssl.h>
+		typedef STACK_OF(X509) Cryptography_STACK_OF_X509; // replacement for STACK_OF(X509)
+	''',
+	include_dirs=include_dirs,
+	library_dirs=library_dirs,
+	libraries=['libcrypto', 'libssl'] if os.name == 'nt' else ['crypto', 'ssl'])
+
+# add all openssl constants, types and functions being used
+ffi_builder.cdef('''
+	// constants
+	static const int MBSTRING_ASC;
+	static const int XN_FLAG_RFC2253;
+
+	static const int SSL_VERIFY_PEER;
+	static const int SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
+
+	static const int EVP_PKEY_ED25519;
+	static const int EVP_PKEY_X25519;
+
+	static const int X509_V_ERR_APPLICATION_VERIFICATION;
+	static const int X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN;
+
+	static const int X509_V_FLAG_CHECK_SS_SIGNATURE;
+
+	// types
+	typedef ... SSL_CTX;
+	typedef ... BIO;
+	typedef ... BIO_METHOD;
+	typedef ... ENGINE;
+	typedef ... EVP_MD;
+	typedef ... EVP_PKEY;
+	typedef ... X509;
+	typedef ... Cryptography_STACK_OF_X509;
+	typedef ... X509_STORE;
+	typedef ... X509_STORE_CTX;
+	typedef ... X509_NAME;
+	typedef ... ASN1_INTEGER;
+	typedef ... ASN1_TIME;
+
+	// SSL_CTX
+	void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, int (*verify_callback)(int, X509_STORE_CTX *));
+
+	// BIO_METHOD
+	const BIO_METHOD * BIO_s_mem(void);
+
+	// BIO
+	BIO* BIO_new(const BIO_METHOD *type);
+	int BIO_free(BIO *a);
+	long BIO_get_mem_data(BIO *b, char **pp);
+
+	// EVP_PKEY
+	EVP_PKEY *EVP_PKEY_new_raw_private_key(int type, ENGINE *e, const unsigned char *key, size_t keylen);
+	void EVP_PKEY_free(EVP_PKEY *key);
+	int EVP_PKEY_id(const EVP_PKEY *pkey);
+	int EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey, unsigned char *pub, size_t *len);
+
+	// X509
+	X509 *X509_new(void);
+	void X509_free(X509 *a);
+	EVP_PKEY *X509_get0_pubkey(const X509 *x);
+	X509_NAME *X509_get_subject_name(const X509 *x);
+	X509_NAME *X509_get_issuer_name(const X509 *x);
+	ASN1_INTEGER *X509_get_serialNumber(X509 *x);
+	ASN1_TIME *X509_getm_notBefore(const X509 *x);
+	ASN1_TIME *X509_getm_notAfter(const X509 *x);
+	int X509_set_pubkey(X509 *x, EVP_PKEY *pkey);
+	int X509_set_version(X509 *x, long version);
+	int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
+
+	// STACK_OF(X509)
+	Cryptography_STACK_OF_X509 *sk_X509_new_null(void);
+	void sk_X509_free(Cryptography_STACK_OF_X509 *sk);
+	int sk_X509_num(const Cryptography_STACK_OF_X509 *sk);
+	int sk_X509_push(Cryptography_STACK_OF_X509 *sk, X509 *ptr);
+
+	// X509_STORE
+	X509_STORE *X509_STORE_new(void);
+	void X509_STORE_free(X509_STORE *v);
+	int X509_STORE_add_cert(X509_STORE *ctx, X509 *x);
+
+	// X509_STORE_CTX
+	X509_STORE_CTX *X509_STORE_CTX_new(void);
+	void X509_STORE_CTX_free(X509_STORE_CTX *ctx);
+	int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *trust_store, X509 *target, Cryptography_STACK_OF_X509 *untrusted);
+	Cryptography_STACK_OF_X509 *X509_STORE_CTX_get0_chain(X509_STORE_CTX *ctx);
+	X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx);
+	int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx);
+	void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int s);
+	void X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x);
+	void X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *ctx, Cryptography_STACK_OF_X509 *chain);
+	void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags);
+	int X509_verify_cert(X509_STORE_CTX *ctx);
+
+	// X509_NAME
+	int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type, const unsigned char *bytes, int len, int loc, int set);
+	int X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent, unsigned long flags);
+
+	// ASN1_INTEGER
+	int ASN1_INTEGER_set(ASN1_INTEGER *a, long v);
+
+	// ASN1_TIME
+	ASN1_TIME *X509_gmtime_adj(ASN1_TIME *asn1_time, long offset_sec);
+''')
+
+if '__main__' == __name__:
+	ffi_builder.compile(verbose=True)

nemtus_symbol_lightapi-0.0.9/nemtus_symbol_lightapi.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: nemtus-symbol-lightapi
+Version: 0.0.9
+Summary: Symbol Light API (NEMTUS mirror of upstream symbol-lightapi; import module: symbollightapi)
+Home-page: https://github.com/nemtus/symbol-product/tree/dev/lightapi/python
+Author: NEMTUS
+Author-email: info@nemtus.com
+License: MIT
+Keywords: symbol,symbollightapi,lightapi,Symbol Light API,nemtus
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp~=3.14.0
+Requires-Dist: aiolimiter~=1.2.1
+Requires-Dist: nemtus-symbol-sdk~=3.3.2
+Requires-Dist: zenlog~=1.1
+
+# Python Light API
+
+Provides partial Python wrappers for calling NEM and Symbol API functions.
+
+Only a subset of APIs are currently supported.
+
+PRs are accepted for extending the set of APIs.

nemtus_symbol_lightapi-0.0.9/nemtus_symbol_lightapi.egg-info/SOURCES.txt

@@ -0,0 +1,51 @@
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+cffi_src/__init__.py
+cffi_src/openssl_build.py
+nemtus_symbol_lightapi.egg-info/PKG-INFO
+nemtus_symbol_lightapi.egg-info/SOURCES.txt
+nemtus_symbol_lightapi.egg-info/dependency_links.txt
+nemtus_symbol_lightapi.egg-info/not-zip-safe
+nemtus_symbol_lightapi.egg-info/requires.txt
+nemtus_symbol_lightapi.egg-info/top_level.txt
+symbollightapi/__init__.py
+symbollightapi/bindings/__init__.py
+symbollightapi/bindings/openssl.py
+symbollightapi/connector/BasicConnector.py
+symbollightapi/connector/CatapultCertificateProcessor.py
+symbollightapi/connector/CertificateUtils.py
+symbollightapi/connector/ConnectorExtensions.py
+symbollightapi/connector/NemBlockCalculator.py
+symbollightapi/connector/NemConnector.py
+symbollightapi/connector/SymbolConnector.py
+symbollightapi/connector/SymbolPeerConnector.py
+symbollightapi/connector/__init__.py
+symbollightapi/model/Block.py
+symbollightapi/model/Constants.py
+symbollightapi/model/Endpoint.py
+symbollightapi/model/Exceptions.py
+symbollightapi/model/NodeInfo.py
+symbollightapi/model/PacketHeader.py
+symbollightapi/model/Transaction.py
+symbollightapi/model/__init__.py
+tests/__init__.py
+tests/connector/__init__.py
+tests/connector/test_BasicConnector.py
+tests/connector/test_CatapultCertificateProcessor.py
+tests/connector/test_CertificateUtils.py
+tests/connector/test_ConnectorExtensions.py
+tests/connector/test_NemBlockCalculator.py
+tests/connector/test_NemConnector.py
+tests/connector/test_SymbolConnector.py
+tests/connector/test_SymbolPeerConnector.py
+tests/model/__init__.py
+tests/model/test_Block.py
+tests/model/test_Endpoint.py
+tests/model/test_NodeInfo.py
+tests/model/test_PacketHeader.py
+tests/model/test_Transaction.py
+tests/test/CertificateTestUtils.py
+tests/test/LightApiTestUtils.py
+tests/test/__init__.py

nemtus_symbol_lightapi-0.0.9/nemtus_symbol_lightapi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nemtus_symbol_lightapi-0.0.9/nemtus_symbol_lightapi.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

nemtus_symbol_lightapi-0.0.9/nemtus_symbol_lightapi.egg-info/requires.txt

@@ -0,0 +1,4 @@
+aiohttp~=3.14.0
+aiolimiter~=1.2.1
+nemtus-symbol-sdk~=3.3.2
+zenlog~=1.1

nemtus_symbol_lightapi-0.0.9/nemtus_symbol_lightapi.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+_openssl_symbol
+cffi_src
+symbollightapi
+tests

nemtus_symbol_lightapi-0.0.9/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = [
+	"setuptools>=61",
+	"wheel",
+	"cffi>=1.15.0",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+filterwarnings = [
+	"ignore:The 'warn' method is deprecated:DeprecationWarning"
+]

nemtus_symbol_lightapi-0.0.9/setup.cfg

@@ -0,0 +1,33 @@
+[metadata]
+name = nemtus-symbol-lightapi
+version = 0.0.9
+author = NEMTUS
+author_email = info@nemtus.com
+description = Symbol Light API (NEMTUS mirror of upstream symbol-lightapi; import module: symbollightapi)
+long_description = file: README.md
+long_description_content_type = text/markdown
+keywords = symbol, symbollightapi, lightapi, Symbol Light API, nemtus
+license = MIT
+classifiers = 
+	Programming Language :: Python :: 3.10
+	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.12
+	Programming Language :: Python :: 3.13
+	Programming Language :: Python :: 3.14
+url = https://github.com/nemtus/symbol-product/tree/dev/lightapi/python
+
+[options]
+zip_safe = False
+include_package_data = True
+packages = find:
+python_requires = >=3.10
+install_requires = 
+	aiohttp~=3.14.0
+	aiolimiter~=1.2.1
+	nemtus-symbol-sdk~=3.3.2
+	zenlog~=1.1
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

nemtus_symbol_lightapi-0.0.9/setup.py

@@ -0,0 +1,34 @@
+import platform
+import sys
+
+from setuptools import setup
+
+cmdclass = {}
+
+if 'CPython' == platform.python_implementation():
+	try:
+		import wheel.bdist_wheel
+
+		class BDistWheel(wheel.bdist_wheel.bdist_wheel):
+			def __init__(self, dist, **kw):
+				super().__init__(dist, **kw)
+				self.py_limited_api = None
+
+			def finalize_options(self):
+				self.py_limited_api = f'cp3{sys.version_info[1]}'
+				wheel.bdist_wheel.bdist_wheel.finalize_options(self)
+
+		cmdclass['bdist_wheel'] = BDistWheel
+	except ImportError:
+		pass
+
+
+if '__main__' == __name__:
+	setup(
+		# Ensure limited API is set on CPython
+		cmdclass=cmdclass,
+		# CFFI
+		zip_safe=False,
+		ext_package='symbollightapi/bindings',
+		cffi_modules=['cffi_src/openssl_build.py:ffi_builder'],
+	)

nemtus_symbol_lightapi-0.0.9/symbollightapi/bindings/openssl.py

@@ -0,0 +1,7 @@
+from cryptography.hazmat.bindings.openssl.binding import Binding as OpensslBinding
+
+from ._openssl_symbol import ffi, lib  # pylint: disable=no-name-in-module, unused-import
+
+# initialize openssl
+if not OpensslBinding.lib:
+	OpensslBinding()

nemtus_symbol_lightapi-0.0.9/symbollightapi/connector/BasicConnector.py

@@ -0,0 +1,62 @@
+import asyncio
+import json
+
+from aiohttp import ClientSession, ClientTimeout, client_exceptions
+
+from ..model.Exceptions import HttpException, NodeException
+
+
+class BasicConnector:
+	"""Async connector for interacting with a node."""
+
+	def __init__(self, endpoint):
+		"""Creates a connector around an endpoint."""
+
+		self.endpoint = endpoint
+		self.timeout_seconds = None
+
+	async def _dispatch(self, action, url_path, property_name, not_found_as_error, **kwargs):
+		try:
+			timeout = ClientTimeout(total=self.timeout_seconds)
+			async with ClientSession(timeout=timeout) as session:
+				async with getattr(session, action)(f'{self.endpoint}/{url_path}', **kwargs) as response:
+					try:
+						response_json = await response.json()
+					except (client_exceptions.ContentTypeError, json.decoder.JSONDecodeError) as ex:
+						raise NodeException from ex
+
+					if 400 <= response.status and (404 != response.status or not_found_as_error):
+						error_message = f'HTTP request failed with code {response.status}'
+						for key in ('code', 'message'):
+							if key in response_json:
+								error_message += f'\n{response_json[key]}'
+
+						raise HttpException(error_message, response.status)
+
+					return response_json if property_name is None else response_json[property_name]
+		except (asyncio.TimeoutError, client_exceptions.ClientConnectorError) as ex:
+			raise NodeException from ex
+
+	async def get(self, url_path, property_name=None, not_found_as_error=True):
+		"""
+		Initiates a GET to the specified path and returns the desired property.
+		Raises NodeException on connection or content failure.
+		"""
+
+		return await self._dispatch('get', url_path, property_name, not_found_as_error)
+
+	async def post(self, url_path, request_payload, property_name=None, not_found_as_error=True):
+		"""
+		Initiates a POST to the specified path and returns the desired property.
+		Raises NodeException on connection or content failure.
+		"""
+
+		return await self._dispatch('post', url_path, property_name, not_found_as_error, json=request_payload)
+
+	async def put(self, url_path, request_payload, property_name=None, not_found_as_error=True):
+		"""
+		Initiates a PUT to the specified path and returns the desired property.
+		Raises NodeException on connection or content failure.
+		"""
+
+		return await self._dispatch('put', url_path, property_name, not_found_as_error, json=request_payload)

nemtus_symbol_lightapi-0.0.9/symbollightapi/connector/CatapultCertificateProcessor.py

@@ -0,0 +1,76 @@
+from zenlog import log
+
+from ..bindings.openssl import lib
+from .CertificateUtils import try_parse_certificate, verify_self_signed
+
+
+class CatapultCertificateProcessor:
+	"""Catapult-specific certificate processor."""
+
+	def __init__(self):
+		"""Creates a new certificate processor."""
+
+		self.certificate_infos = []
+
+	@property
+	def size(self):
+		"""Gets the number of certificates in the chain."""
+
+		return len(self.certificate_infos)
+
+	def certificate(self, depth):
+		"""
+		Gets the parsed certificate information at depth.
+		Depth is 0-based starting with the root certificate.
+		"""
+
+		return self.certificate_infos[depth]
+
+	def verify(self, preverified, certificate_store_context):
+		"""Verifies the current certificate in certificate_store_context given preverified result."""
+
+		# reject all certificate chains that are not composed of two certificates
+		chain = lib.X509_STORE_CTX_get0_chain(certificate_store_context)
+		chain_size = lib.sk_X509_num(chain)
+		if 2 != chain_size:
+			log.warning(f'rejecting certificate chain with size {chain_size}')
+			return False
+
+		certificate = lib.X509_STORE_CTX_get_current_cert(certificate_store_context)
+		if not certificate:
+			raise RuntimeError('rejecting certificate chain with no active certificate')
+
+		if preverified:
+			if self._push(certificate):
+				return True
+
+			lib.X509_STORE_CTX_set_error(certificate_store_context, lib.X509_V_ERR_APPLICATION_VERIFICATION)
+			return False
+
+		error_code = lib.X509_STORE_CTX_get_error(certificate_store_context)
+		return self.verify_unverified_root(certificate, error_code)
+
+	def verify_unverified_root(self, certificate, error_code):
+		if self.certificate_infos:
+			log.warning('rejecting certificate chain with unverified non-root certificate')
+			return False
+
+		# only verify self signed certificates
+		if lib.X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN != error_code:
+			log.warning(f'rejecting certificate chain with unverified unexpected error {error_code}')
+			return False
+
+		if not verify_self_signed(certificate):
+			log.warning('rejecting certificate chain with improperly self-signed root certificate')
+			return False
+
+		return True
+
+	def _push(self, certificate):
+		certificate_info = try_parse_certificate(certificate)
+		if not certificate_info:
+			log.warning('rejecting certificate chain due to certificate parse failure')
+			return False
+
+		self.certificate_infos.append(certificate_info)
+		return True

nemtus_symbol_lightapi-0.0.9/symbollightapi/connector/CertificateUtils.py

@@ -0,0 +1,66 @@
+from collections import namedtuple
+
+from symbolchain.CryptoTypes import PublicKey
+
+from symbollightapi.bindings.openssl import ffi, lib
+
+CertificateInfo = namedtuple('CertificateInfo', ['subject', 'public_key'])
+
+# region try_parse_certificate
+
+
+def _extract_one_line(name):
+	bio = ffi.gc(lib.BIO_new(lib.BIO_s_mem()), lib.BIO_free)
+
+	if -1 == lib.X509_NAME_print_ex(bio, name, 0, lib.XN_FLAG_RFC2253):
+		return None
+
+	raw_data = ffi.new('char **')
+	data_size = lib.BIO_get_mem_data(bio, raw_data)
+	data = ffi.buffer(raw_data[0], data_size)[:]
+	return data.decode('utf8')
+
+
+def try_parse_certificate(certificate):
+	"""Tries to extract information about certificate."""
+
+	subject_x509_name = lib.X509_get_subject_name(certificate)
+	subject = _extract_one_line(subject_x509_name)
+
+	certificate_public_key = lib.X509_get0_pubkey(certificate)
+	if not certificate_public_key:
+		return None
+
+	if lib.EVP_PKEY_ED25519 != lib.EVP_PKEY_id(ffi.cast('EVP_PKEY *', certificate_public_key)):
+		return None
+
+	public_key = PublicKey(bytes(PublicKey.SIZE))
+	key_size_pointer = ffi.new('size_t *', PublicKey.SIZE)
+	if not lib.EVP_PKEY_get_raw_public_key(certificate_public_key, public_key.bytes, key_size_pointer):
+		return None
+
+	if PublicKey.SIZE != key_size_pointer[0]:
+		return None
+
+	return CertificateInfo(subject, public_key)
+
+# endregion
+
+
+# region verify_self_signed
+
+def verify_self_signed(certificate):
+	"""Returns True if self-signed certificate signature is correct."""
+
+	certificate_store = ffi.gc(lib.X509_STORE_new(), lib.X509_STORE_free)
+	if not lib.X509_STORE_add_cert(certificate_store, certificate):
+		return False
+
+	certificate_store_context = ffi.gc(lib.X509_STORE_CTX_new(), lib.X509_STORE_CTX_free)
+	if not lib.X509_STORE_CTX_init(certificate_store_context, certificate_store, certificate, ffi.cast('Cryptography_STACK_OF_X509 *', 0)):
+		return False
+
+	lib.X509_STORE_CTX_set_flags(certificate_store_context, lib.X509_V_FLAG_CHECK_SS_SIGNATURE)
+	return 1 == lib.X509_verify_cert(certificate_store_context)
+
+# endregion

nemtus_symbol_lightapi-0.0.9/symbollightapi/connector/ConnectorExtensions.py

@@ -0,0 +1,65 @@
+import asyncio
+
+from aiolimiter import AsyncLimiter
+
+from ..model.Constants import DEFAULT_ASYNC_LIMITER_ARGUMENTS
+
+# region get_incoming_transactions_from
+
+
+async def get_incoming_transactions_from(connector, address, start_height=None, end_height=None):
+	"""Uses the specified connector to retrieve all transactions sent to an account in the range [start_height, end_height)."""
+
+	start_id = None
+	while True:
+		transactions_json = await connector.incoming_transactions(address, start_id)
+		if not transactions_json:
+			return
+
+		for transaction_json in transactions_json:
+			transaction_height = int(transaction_json['meta']['height'])
+			if start_height and transaction_height < start_height:
+				return
+
+			if end_height and transaction_height >= end_height:
+				continue
+
+			yield transaction_json
+
+		start_id = connector.extract_transaction_id(transactions_json[-1])
+
+# endregion
+
+
+# region filter_finalized_transactions
+
+async def filter_finalized_transactions(connector, transaction_hashes):
+	"""Filters transaction hashes and returns only finalized ones with heights."""
+
+	finalized_chain_height = await connector.finalized_chain_height()
+	transaction_hash_height_pairs = await connector.filter_confirmed_transactions(transaction_hashes)
+	return list(filter(
+		lambda transaction_hash_height_pair: transaction_hash_height_pair[1] <= finalized_chain_height,
+		transaction_hash_height_pairs))
+
+# endregion
+
+
+# region query_block_timestamps
+
+async def query_block_timestamps(connector, heights, async_limiter_arguments=DEFAULT_ASYNC_LIMITER_ARGUMENTS):
+	"""Finds the timestamps for all blocks with the specified heights."""
+
+	limiter = AsyncLimiter(*async_limiter_arguments)
+
+	async def get_block_height_timestamp_pair(height):
+		async with limiter:
+			block_json = await connector.block_headers(height)
+			timestamp = connector.extract_block_timestamp(block_json)
+			return (height, timestamp)
+
+	tasks = [get_block_height_timestamp_pair(height) for height in heights]
+	block_height_timestamp_pairs = await asyncio.gather(*tasks)
+	return block_height_timestamp_pairs
+
+# endregion