nemtus-symbol-sdk 3.3.2__tar.gz

nemtus_symbol_sdk-3.3.2/LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+This package is a redistribution of `symbol-sdk-python` (import module
+`symbolchain`) from the upstream project symbol/symbol
+(https://github.com/symbol/symbol), published by its authors — identified in the
+upstream package metadata as "Symbol Contributors <contributors@symbol.dev>" —
+under the MIT License. The nemtus mirror asserts no copyright over this software
+and changes nothing but the published PyPI distribution name (to
+`nemtus-symbol-sdk`). The authoritative copyright and license are upstream's.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nemtus_symbol_sdk-3.3.2/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: nemtus-symbol-sdk
+Version: 3.3.2
+Summary: Symbol Python SDK (nemtus mirror of upstream symbol-sdk-python; import module: symbolchain)
+License: MIT
+License-File: LICENSE
+Keywords: symbol,sdk,Symbol SDK
+Author: Symbol Contributors
+Author-email: contributors@symbol.dev
+Maintainer: Symbol Contributors
+Maintainer-email: contributors@symbol.dev
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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-Dist: cryptography (>=49.0.0,<49.1.0)
+Requires-Dist: mnemonic (>=0.20,<1.0)
+Requires-Dist: pillow (>=12.2.0,<12.3.0)
+Requires-Dist: pynacl (>=1.6.0,<1.7.0)
+Requires-Dist: pyyaml (>=6.0.1,<6.1.0)
+Requires-Dist: pyzbar (>=0.1.9,<0.2.0)
+Requires-Dist: qrcode (>=8.0,<9.0)
+Requires-Dist: ripemd-hash (>=1.0.1,<1.1.0)
+Requires-Dist: safe-pysha3 (>=1.0.4,<1.1.0)
+Project-URL: Repository, https://github.com/nemtus/symbol/tree/dev/sdk/python
+Description-Content-Type: text/markdown
+
+<!-- nemtus-mirror-notice -->
+> **Note (nemtus mirror):** This package is a content mirror of the **Python** SDK
+> from [`symbol/symbol`](https://github.com/symbol/symbol) (`sdk/python`, upstream
+> PyPI name `symbol-sdk-python`). nemtus republishes it on PyPI as
+> [`nemtus-symbol-sdk`](https://pypi.org/project/nemtus-symbol-sdk/); the only
+> change from upstream is the published distribution name. The import module name
+> is unchanged — you still `import symbolchain`. This is distinct from
+> `@nemtus/symbol-sdk` on npm, which mirrors the JavaScript SDK. For the canonical
+> project, see [symbol/symbol](https://github.com/symbol/symbol).
+<!-- /nemtus-mirror-notice -->
+
+# Symbol-SDK
+
+[![lint][sdk-python-lint]][sdk-python-job] [![test][sdk-python-test]][sdk-python-job] [![vectors][sdk-python-vectors]][sdk-python-job] [![][sdk-python-cov]][sdk-python-cov-link] [![][sdk-python-package]][sdk-python-package-link]
+
+[sdk-python-job]: https://jenkins.symbolsyndicate.us/blue/organizations/jenkins/Symbol%2Fgenerated%2Fsymbol%2Fpython/activity?branch=dev
+[sdk-python-lint]: https://jenkins.symbolsyndicate.us/buildStatus/icon?job=Symbol%2Fgenerated%2Fsymbol%2Fpython%2Fdev%2F&config=sdk-python-lint
+[sdk-python-build]: https://jenkins.symbolsyndicate.us/buildStatus/icon?job=Symbol%2Fgenerated%2Fsymbol%2Fpython%2Fdev%2F&config=sdk-python-build
+[sdk-python-test]: https://jenkins.symbolsyndicate.us/buildStatus/icon?job=Symbol%2Fgenerated%2Fsymbol%2Fpython%2Fdev%2F&config=sdk-python-test
+[sdk-python-examples]: https://jenkins.symbolsyndicate.us/buildStatus/icon?job=Symbol%2Fgenerated%2Fsymbol%2Fpython%2Fdev%2F&config=sdk-python-examples
+[sdk-python-vectors]: https://jenkins.symbolsyndicate.us/buildStatus/icon?job=Symbol%2Fgenerated%2Fsymbol%2Fpython%2Fdev%2F&config=sdk-python-vectors
+[sdk-python-cov]: https://codecov.io/gh/symbol/symbol/branch/dev/graph/badge.svg?token=SSYYBMK0M7&flag=sdk-python
+[sdk-python-cov-link]: https://codecov.io/gh/symbol/symbol/tree/dev/sdk/python
+[sdk-python-package]: https://img.shields.io/pypi/v/symbol-sdk-python
+[sdk-python-package-link]: https://pypi.org/project/symbol-sdk-python
+
+Python SDK for interacting with the Symbol and NEM blockchains.
+
+Most common functionality is grouped under facades so that the same programming paradigm can be used for interacting with both Symbol and NEM.
+
+## Sending a Transaction
+
+To send a transaction, first create a facade for the desired network:
+
+_Symbol_
+```python
+from symbolchain.CryptoTypes import PrivateKey
+from symbolchain.facade.SymbolFacade import SymbolFacade
+
+
+facade = SymbolFacade('testnet')
+```
+
+_NEM_
+```python
+from symbolchain.CryptoTypes import PrivateKey
+from symbolchain.facade.NemFacade import NemFacade
+
+facade = NemFacade('testnet')
+````
+
+Second, describe the transaction using a Python dictionary. For example, a transfer transaction can be described as follows:
+
+_Symbol_
+```python
+transaction = facade.transaction_factory.create({
+	'type': 'transfer_transaction_v1',
+	'signer_public_key': '87DA603E7BE5656C45692D5FC7F6D0EF8F24BB7A5C10ED5FDA8C5CFBC49FCBC8',
+	'fee': 1000000,
+	'deadline': 41998024783,
+	'recipient_address': 'TCHBDENCLKEBILBPWP3JPB2XNY64OE7PYHHE32I',
+	'mosaics': [
+		{'mosaic_id': 0x7CDF3B117A3C40CC, 'amount': 1000000}
+	]
+})
+```
+
+_NEM_
+```python
+transaction = facade.transaction_factory.create({
+	'type': 'transfer_transaction_v1',
+	'signer_public_key': 'A59277D56E9F4FA46854F5EFAAA253B09F8AE69A473565E01FD9E6A738E4AB74',
+	'fee': 0x186A0,
+	'timestamp': 191205516,
+	'deadline': 191291916,
+	'recipient_address': 'TALICE5VF6J5FYMTCB7A3QG6OIRDRUXDWJGFVXNW',
+	'amount': 5100000
+})
+````
+
+Third, sign the transaction and attach the signature:
+
+
+```python
+private_key = PrivateKey('EDB671EB741BD676969D8A035271D1EE5E75DF33278083D877F23615EB839FEC')
+signature = facade.sign_transaction(facade.KeyPair(private_key), transaction)
+
+json_payload = facade.transaction_factory.attach_signature(transaction, signature)
+```
+
+Finally, send the payload to the desired network using the specified node endpoint:
+
+_Symbol_: PUT `/transactions`
+<br>
+_NEM_: POST `/transaction/announce`
+
+
+## NEM Cheat Sheet
+
+In order to simplify the learning curve for NEM and Symbol usage, the SDK uses Symbol terminology for shared Symbol and NEM concepts.
+Where appropriate, NEM terminology is replaced with Symbol terminology, including the names of many of the NEM transactions.
+The mapping of NEM transactions to SDK descriptors can be found in the following table:
+
+| NEM name (used in docs) | SDK descriptor name|
+|--- |--- |
+| ImportanceTransfer transaction | `account_key_link_transaction_v1` |
+| MosaicDefinitionCreation transaction | `mosaic_definition_transaction_v1` |
+| MosaicSupplyChange transaction | `mosaic_supply_change_transaction_v1` |
+| MultisigAggregateModification transaction | `multisig_account_modification_transaction_v1`<br>`multisig_account_modification_transaction_v2` |
+| MultisigSignature transaction or Cosignature transaction | `cosignature_v1` |
+| Multisig transaction | `multisig_transaction_v1` |
+| ProvisionNamespace transaction | `namespace_registration_transaction_v1` |
+| Transfer transaction | `transfer_transaction_v1`<br>`transfer_transaction_v2` |
+

nemtus_symbol_sdk-3.3.2/README.md

@@ -0,0 +1,113 @@
+<!-- nemtus-mirror-notice -->
+> **Note (nemtus mirror):** This package is a content mirror of the **Python** SDK
+> from [`symbol/symbol`](https://github.com/symbol/symbol) (`sdk/python`, upstream
+> PyPI name `symbol-sdk-python`). nemtus republishes it on PyPI as
+> [`nemtus-symbol-sdk`](https://pypi.org/project/nemtus-symbol-sdk/); the only
+> change from upstream is the published distribution name. The import module name
+> is unchanged — you still `import symbolchain`. This is distinct from
+> `@nemtus/symbol-sdk` on npm, which mirrors the JavaScript SDK. For the canonical
+> project, see [symbol/symbol](https://github.com/symbol/symbol).
+<!-- /nemtus-mirror-notice -->
+
+# Symbol-SDK
+
+[![lint][sdk-python-lint]][sdk-python-job] [![test][sdk-python-test]][sdk-python-job] [![vectors][sdk-python-vectors]][sdk-python-job] [![][sdk-python-cov]][sdk-python-cov-link] [![][sdk-python-package]][sdk-python-package-link]
+
+[sdk-python-job]: https://jenkins.symbolsyndicate.us/blue/organizations/jenkins/Symbol%2Fgenerated%2Fsymbol%2Fpython/activity?branch=dev
+[sdk-python-lint]: https://jenkins.symbolsyndicate.us/buildStatus/icon?job=Symbol%2Fgenerated%2Fsymbol%2Fpython%2Fdev%2F&config=sdk-python-lint
+[sdk-python-build]: https://jenkins.symbolsyndicate.us/buildStatus/icon?job=Symbol%2Fgenerated%2Fsymbol%2Fpython%2Fdev%2F&config=sdk-python-build
+[sdk-python-test]: https://jenkins.symbolsyndicate.us/buildStatus/icon?job=Symbol%2Fgenerated%2Fsymbol%2Fpython%2Fdev%2F&config=sdk-python-test
+[sdk-python-examples]: https://jenkins.symbolsyndicate.us/buildStatus/icon?job=Symbol%2Fgenerated%2Fsymbol%2Fpython%2Fdev%2F&config=sdk-python-examples
+[sdk-python-vectors]: https://jenkins.symbolsyndicate.us/buildStatus/icon?job=Symbol%2Fgenerated%2Fsymbol%2Fpython%2Fdev%2F&config=sdk-python-vectors
+[sdk-python-cov]: https://codecov.io/gh/symbol/symbol/branch/dev/graph/badge.svg?token=SSYYBMK0M7&flag=sdk-python
+[sdk-python-cov-link]: https://codecov.io/gh/symbol/symbol/tree/dev/sdk/python
+[sdk-python-package]: https://img.shields.io/pypi/v/symbol-sdk-python
+[sdk-python-package-link]: https://pypi.org/project/symbol-sdk-python
+
+Python SDK for interacting with the Symbol and NEM blockchains.
+
+Most common functionality is grouped under facades so that the same programming paradigm can be used for interacting with both Symbol and NEM.
+
+## Sending a Transaction
+
+To send a transaction, first create a facade for the desired network:
+
+_Symbol_
+```python
+from symbolchain.CryptoTypes import PrivateKey
+from symbolchain.facade.SymbolFacade import SymbolFacade
+
+
+facade = SymbolFacade('testnet')
+```
+
+_NEM_
+```python
+from symbolchain.CryptoTypes import PrivateKey
+from symbolchain.facade.NemFacade import NemFacade
+
+facade = NemFacade('testnet')
+````
+
+Second, describe the transaction using a Python dictionary. For example, a transfer transaction can be described as follows:
+
+_Symbol_
+```python
+transaction = facade.transaction_factory.create({
+	'type': 'transfer_transaction_v1',
+	'signer_public_key': '87DA603E7BE5656C45692D5FC7F6D0EF8F24BB7A5C10ED5FDA8C5CFBC49FCBC8',
+	'fee': 1000000,
+	'deadline': 41998024783,
+	'recipient_address': 'TCHBDENCLKEBILBPWP3JPB2XNY64OE7PYHHE32I',
+	'mosaics': [
+		{'mosaic_id': 0x7CDF3B117A3C40CC, 'amount': 1000000}
+	]
+})
+```
+
+_NEM_
+```python
+transaction = facade.transaction_factory.create({
+	'type': 'transfer_transaction_v1',
+	'signer_public_key': 'A59277D56E9F4FA46854F5EFAAA253B09F8AE69A473565E01FD9E6A738E4AB74',
+	'fee': 0x186A0,
+	'timestamp': 191205516,
+	'deadline': 191291916,
+	'recipient_address': 'TALICE5VF6J5FYMTCB7A3QG6OIRDRUXDWJGFVXNW',
+	'amount': 5100000
+})
+````
+
+Third, sign the transaction and attach the signature:
+
+
+```python
+private_key = PrivateKey('EDB671EB741BD676969D8A035271D1EE5E75DF33278083D877F23615EB839FEC')
+signature = facade.sign_transaction(facade.KeyPair(private_key), transaction)
+
+json_payload = facade.transaction_factory.attach_signature(transaction, signature)
+```
+
+Finally, send the payload to the desired network using the specified node endpoint:
+
+_Symbol_: PUT `/transactions`
+<br>
+_NEM_: POST `/transaction/announce`
+
+
+## NEM Cheat Sheet
+
+In order to simplify the learning curve for NEM and Symbol usage, the SDK uses Symbol terminology for shared Symbol and NEM concepts.
+Where appropriate, NEM terminology is replaced with Symbol terminology, including the names of many of the NEM transactions.
+The mapping of NEM transactions to SDK descriptors can be found in the following table:
+
+| NEM name (used in docs) | SDK descriptor name|
+|--- |--- |
+| ImportanceTransfer transaction | `account_key_link_transaction_v1` |
+| MosaicDefinitionCreation transaction | `mosaic_definition_transaction_v1` |
+| MosaicSupplyChange transaction | `mosaic_supply_change_transaction_v1` |
+| MultisigAggregateModification transaction | `multisig_account_modification_transaction_v1`<br>`multisig_account_modification_transaction_v2` |
+| MultisigSignature transaction or Cosignature transaction | `cosignature_v1` |
+| Multisig transaction | `multisig_transaction_v1` |
+| ProvisionNamespace transaction | `namespace_registration_transaction_v1` |
+| Transfer transaction | `transfer_transaction_v1`<br>`transfer_transaction_v2` |

nemtus_symbol_sdk-3.3.2/pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = 'nemtus-symbol-sdk'
+version = '3.3.2'
+description = 'Symbol Python SDK (nemtus mirror of upstream symbol-sdk-python; import module: symbolchain)'
+authors = ['Symbol Contributors <contributors@symbol.dev>']
+maintainers = ['Symbol Contributors <contributors@symbol.dev>']
+license = 'MIT'
+
+readme = 'README.md'
+
+packages = [{ include = 'symbolchain' }]
+
+repository = 'https://github.com/nemtus/symbol/tree/dev/sdk/python'
+
+keywords = ['symbol', 'sdk', 'Symbol SDK']
+
+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']
+
+[tool.poetry.dependencies]
+python = "^3.10"
+cryptography = ">=49.0.0,<49.1.0"
+mnemonic = ">=0.20,<1.0"
+pillow = ">=12.2.0,<12.3.0"
+pynacl = ">=1.6.0,<1.7.0"
+pyyaml = ">=6.0.1,<6.1.0"
+pyzbar = ">=0.1.9,<0.2.0"
+qrcode = ">=8.0,<9.0"
+ripemd-hash = ">=1.0.1,<1.1.0"
+safe-pysha3 = ">=1.0.4,<1.1.0"

nemtus_symbol_sdk-3.3.2/symbolchain/AccountDescriptorRepository.py

@@ -0,0 +1,59 @@
+import yaml
+
+from .CryptoTypes import PublicKey
+
+
+class AccountDescriptor:
+	"""Represents an account."""
+
+	def __init__(self, descriptor_yaml):
+		"""Creates a descriptor from a yaml container."""
+		self.public_key = descriptor_yaml.get('public_key')
+		if self.public_key:
+			self.public_key = PublicKey(self.public_key)
+
+		self.address = descriptor_yaml.get('address')
+		self.name = descriptor_yaml.get('name')
+		self.roles = descriptor_yaml.get('roles') or []
+
+
+class AccountDescriptorRepository:
+	"""Loads read-only account descriptors from YAML."""
+
+	def __init__(self, yaml_input):
+		"""Loads account descriptors from the specified input."""
+		descriptors_yaml = yaml_input if isinstance(yaml_input, list) else yaml.load(yaml_input, Loader=yaml.SafeLoader)
+		self.descriptors = [AccountDescriptor(descriptor_yaml) for descriptor_yaml in descriptors_yaml]
+
+	def try_find_by_name(self, name):
+		"""Finds the account descriptor with a matching name or None if no matching descriptors are found."""
+		return next((descriptor for descriptor in self.descriptors if name == descriptor.name), None)
+
+	def find_by_public_key(self, public_key):
+		"""Finds the account descriptor with a matching public key."""
+		return next(descriptor for descriptor in self.descriptors if descriptor.public_key and public_key == descriptor.public_key)
+
+	def find_by_address(self, address):
+		"""Finds the account descriptor with a matching address."""
+		return next(descriptor for descriptor in self.descriptors if descriptor.address and str(address) == descriptor.address)
+
+	def find_all_by_role(self, role):
+		"""Finds all account descriptors with a matching role."""
+		return [descriptor for descriptor in self.descriptors if not role or role in descriptor.roles]
+
+	def _lookup_account_descriptor_field(self, value, property_name, target_class):
+		account_descriptor = self.try_find_by_name(value)
+		if account_descriptor and hasattr(account_descriptor, property_name):
+			return target_class(getattr(account_descriptor, property_name))
+
+		return target_class(value)
+
+	def _bind_lookup_account_descriptor_field(self, property_name, target_class):
+		return lambda value: self._lookup_account_descriptor_field(value, property_name, target_class)
+
+	def to_type_parsing_rules_map(self, type_to_property_mapping):
+		"""Builds a type to parsing rule map."""
+		return {
+			target_class: self._bind_lookup_account_descriptor_field(property_name, target_class)
+			for target_class, property_name in type_to_property_mapping.items()
+		}

nemtus_symbol_sdk-3.3.2/symbolchain/ArrayHelpers.py

@@ -0,0 +1,116 @@
+def read_array_impl(view, factory_class, accessor, should_continue):
+	elements = []
+	previous_element = None
+
+	i = 0
+	while should_continue(i, view):
+		element = factory_class.deserialize(view)
+
+		if element.size <= 0:
+			raise ValueError('element size has invalid size')
+
+		if accessor and previous_element and accessor(previous_element) >= accessor(element):
+			raise ValueError('elements in array are not sorted')
+
+		elements.append(element)
+		view = view[element.size:]
+
+		previous_element = element
+		i += 1
+
+	return elements
+
+
+def write_array_impl(elements, count, accessor):
+	output_buffer = bytes()
+	for i in range(0, count):
+		element = elements[i]
+		if accessor and i > 0 and accessor(elements[i - 1]) >= accessor(element):
+			raise ValueError('array passed to write array is not sorted')
+
+		output_buffer += element.serialize()
+
+	return output_buffer
+
+
+class ArrayHelpers:
+	@staticmethod
+	def get_bytes(view, size):
+		"""Returns first size bytes of view."""
+		if size > len(view):
+			raise ValueError(f'size should not exceed {len(view)}. The value of size was: {size}.')
+
+		return view[:size].tobytes()
+
+	@staticmethod
+	def align_up(size, alignment):
+		"""Calculates aligned size."""
+		return (size + alignment - 1) // alignment * alignment
+
+	@staticmethod
+	def size(elements, alignment=0, skip_last_element_padding=False):
+		"""Calculates size of variable size objects."""
+		if not alignment:
+			return sum(map(lambda e: e.size, elements))
+
+		if not skip_last_element_padding:
+			return sum(map(lambda e: ArrayHelpers.align_up(e.size, alignment), elements))
+
+		return sum(map(lambda e: ArrayHelpers.align_up(e.size, alignment), elements[:-1])) + sum(map(lambda e: e.size, elements[-1:]))
+
+	@staticmethod
+	def read_array(view, factory_class, accessor=None):
+		"""Reads array of objects."""
+		return read_array_impl(view, factory_class, accessor, lambda _, view: len(view) > 0)
+
+	@staticmethod
+	def read_array_count(view, factory_class, count, accessor=None):
+		"""Reads array of deterministic number of objects."""
+		return read_array_impl(view, factory_class, accessor, lambda index, _: count > index)
+
+	@staticmethod
+	def read_variable_size_elements(view, factory_class, alignment, skip_last_element_padding=False):
+		"""Reads array of variable size objects."""
+		elements = []
+		while len(view) > 0:
+			element = factory_class.deserialize(view)
+
+			if element.size <= 0:
+				raise ValueError('element size has invalid size')
+
+			elements.append(element)
+
+			aligned_size = ArrayHelpers.align_up(element.size, alignment)
+			if skip_last_element_padding and element.size >= len(view):
+				aligned_size = element.size
+
+			if aligned_size > len(view):
+				raise ValueError('unexpected buffer length')
+
+			view = view[aligned_size:]
+
+		return elements
+
+	@staticmethod
+	def write_array(elements, accessor=None):
+		"""Writes array of objects."""
+		return write_array_impl(elements, len(elements), accessor)
+
+	@staticmethod
+	def write_array_count(elements, count, accessor=None):
+		"""Writes array of deterministic number of objects."""
+		return write_array_impl(elements, count, accessor)
+
+	@staticmethod
+	def write_variable_size_elements(elements, alignment, skip_last_element_padding=False):
+		"""Writes array of variable size objects."""
+		output_buffer = bytes()
+		for index, element in enumerate(elements):
+			output_buffer += element.serialize()
+
+			if not skip_last_element_padding or len(elements) - 1 != index:
+				aligned_size = ArrayHelpers.align_up(element.size, alignment)
+				if aligned_size != element.size:
+					output_buffer += bytes(aligned_size - element.size)
+
+		return output_buffer

nemtus_symbol_sdk-3.3.2/symbolchain/BaseValue.py

@@ -0,0 +1,55 @@
+from .Ordered import Ordered
+
+
+class BaseValue(Ordered):
+	"""Represents a base int."""
+
+	def __init__(self, size, value, tag=None, signed=False):
+		"""Creates a base value."""
+		self.size = size
+		self.value = value
+		self.__tag = (tag, signed)
+
+		# check bounds
+		bit_size = self.size * 8
+		if signed:
+			upper_bound = (1 << (bit_size - 1)) - 1
+			lower_bound = -upper_bound - 1
+		else:
+			upper_bound = (1 << bit_size) - 1
+			lower_bound = 0
+
+		if self.value < lower_bound or self.value > upper_bound:
+			signed_description = 'signed' if signed else 'unsigned'
+			value_range_message = f'{value} must be in range [{lower_bound}, {upper_bound}]'
+			raise ValueError(f'{value_range_message} for {self.size} bytes ({signed_description})')
+
+	def _cmp(self, other, operation):
+		if not isinstance(other, BaseValue):
+			return NotImplemented
+
+		# pylint: disable=protected-access
+		return operation(self.value, other.value) and self.__tag == other.__tag
+
+	def __eq__(self, other):
+		# pylint: disable=protected-access
+		return isinstance(other, BaseValue) and self.value == other.value and self.__tag == other.__tag
+
+	def __ne__(self, other):
+		return not self == other
+
+	def __hash__(self):
+		return hash((self.value, self.__tag))
+
+	def __str__(self):
+		if not self.__tag[1] or self.value >= 0:
+			unsigned_value = self.value
+		else:
+			upper_bound_plus_one = 1 << (self.size * 8)
+			unsigned_value = self.value + upper_bound_plus_one
+
+		return f'0x{unsigned_value:0{self.size * 2}X}'
+
+	def to_json(self):
+		"""Returns representation of this object that can be stored in JSON."""
+		return str(self.value) if 8 <= self.size else self.value

nemtus_symbol_sdk-3.3.2/symbolchain/Bip32.py

@@ -0,0 +1,56 @@
+import hashlib
+import hmac
+import secrets
+
+from mnemonic import Mnemonic
+
+from .BufferWriter import BufferWriter
+from .CryptoTypes import PrivateKey
+
+
+class Bip32Node:
+	"""Representation of a BIP32 node."""
+
+	def __init__(self, hmac_key, data):
+		"""Creates a BIP32 node around a key and data."""
+		hmac_result = hmac.new(hmac_key, data, hashlib.sha512).digest()
+
+		self.private_key = PrivateKey(hmac_result[0:PrivateKey.SIZE])
+		self.chain_code = hmac_result[PrivateKey.SIZE:]
+
+	def derive_one(self, identifier):
+		"""Derives a direct child node with specified identifier."""
+		hmac_data_writer = BufferWriter('big')
+		hmac_data_writer.write_int(0, 1)
+		hmac_data_writer.write_bytes(self.private_key.bytes)
+		hmac_data_writer.write_int(0x80000000 | identifier, 4)
+		return Bip32Node(self.chain_code, hmac_data_writer.buffer)
+
+	def derive_path(self, path):
+		"""Derives a descendent node with specified path."""
+		next_node = self
+		for identifier in path:
+			next_node = next_node.derive_one(identifier)
+
+		return next_node
+
+
+class Bip32:
+	"""Factory of BIP32 root nodes """
+
+	def __init__(self, curve_name='ed25519', mnemonic_language='english'):
+		"""Creates a BIP32 root node factory."""
+		self.root_hmac_key = (curve_name + ' seed').encode('utf8')
+		self.mnemonic_language = mnemonic_language
+
+	def from_seed(self, seed):
+		"""Creates a BIP32 root node from a seed."""
+		return Bip32Node(self.root_hmac_key, seed)
+
+	def from_mnemonic(self, mnemonic, password):
+		"""Creates a BIP32 root node from a BIP39 mnemonic and password."""
+		return self.from_seed(Mnemonic(self.mnemonic_language).to_seed(mnemonic, password))
+
+	def random(self, seed_length=32):
+		"""Creates a random BIP32 mnemonic."""
+		return Mnemonic(self.mnemonic_language).to_mnemonic(secrets.token_bytes(seed_length))

nemtus_symbol_sdk-3.3.2/symbolchain/BlockchainSettings.py

@@ -0,0 +1,21 @@
+import yaml
+
+from .AccountDescriptorRepository import AccountDescriptorRepository
+from .NodeDescriptorRepository import NodeDescriptorRepository
+
+
+class BlockchainSettings:
+	"""Settings describing a blockchain."""
+
+	def __init__(self, settings_dict):
+		"""Creates blockchain settings from a dictionary."""
+		self.blockchain = settings_dict['blockchain']
+		self.network = settings_dict['network']
+		self.nodes = NodeDescriptorRepository(settings_dict['nodes'])
+		self.accounts = AccountDescriptorRepository(settings_dict['accounts'])
+
+	@staticmethod
+	def load_from_yaml(yaml_input):
+		"""Loads settings from YAML."""
+		settings_yaml = yaml.load(yaml_input, Loader=yaml.SafeLoader)
+		return BlockchainSettings(settings_yaml)

nemtus_symbol_sdk-3.3.2/symbolchain/BufferReader.py

@@ -0,0 +1,34 @@
+from binascii import hexlify
+
+
+class BufferReader:
+	"""Reads data from an in memory buffer."""
+
+	def __init__(self, buffer, byte_order='little'):
+		"""Creates a reader with specified byte order."""
+		self.buffer = buffer
+		self.byte_order = byte_order
+		self.offset = 0
+
+	@property
+	def eof(self):
+		"""Returns true if the reader is at eof."""
+		return self.offset == len(self.buffer)
+
+	def read_int(self, count):
+		"""Reads an integer."""
+		return int.from_bytes(self.read_bytes(count), self.byte_order)
+
+	def read_string(self, count):
+		"""Reads a string."""
+		return self.read_bytes(count).decode('utf8')
+
+	def read_hex_string(self, count):
+		"""Reads a hex string."""
+		return hexlify(self.read_bytes(count)).decode('utf8').upper()
+
+	def read_bytes(self, count):
+		"""Reads bytes."""
+		buffer = self.buffer[self.offset:self.offset + count]
+		self.offset += count
+		return buffer