symbol-sdk-python 3.3.0__tar.gz → 3.3.2__tar.gz

{symbol_sdk_python-3.3.0 → symbol_sdk_python-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: symbol-sdk-python
-Version: 3.3.0
+Version: 3.3.2
 Summary: Symbol SDK
 Home-page: https://github.com/symbol/symbol/tree/main/sdk/python
 License: MIT
@@ -9,17 +9,17 @@ Author: Symbol Contributors
 Author-email: contributors@symbol.dev
 Maintainer: Symbol Contributors
 Maintainer-email: contributors@symbol.dev
-Requires-Python: >=3.9.2,<4.0.0
+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.9
-Requires-Dist: cryptography (>=46.0.1,<46.1.0)
+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 (>=11.3.0,<11.4.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)

{symbol_sdk_python-3.3.0 → symbol_sdk_python-3.3.2}/README.md

@@ -1,102 +1,102 @@
-# 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` |
+# 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` |

{symbol_sdk_python-3.3.0 → symbol_sdk_python-3.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = 'symbol-sdk-python'
-version = '3.3.0'
+version = '3.3.2'
 description = 'Symbol SDK'
 authors = ['Symbol Contributors <contributors@symbol.dev>']
 maintainers = ['Symbol Contributors <contributors@symbol.dev>']
@@ -14,13 +14,13 @@ repository = 'https://github.com/symbol/symbol/tree/main/sdk/python'
 
 keywords = ['symbol', 'sdk', 'Symbol SDK']
 
-classifiers = ['Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11']
+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.9.2"
-cryptography = ">=46.0.1,<46.1.0"
+python = "^3.10"
+cryptography = ">=49.0.0,<49.1.0"
 mnemonic = ">=0.20,<1.0"
-pillow = ">=11.3.0,<11.4.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"

{symbol_sdk_python-3.3.0 → symbol_sdk_python-3.3.2}/symbolchain/ArrayHelpers.py

@@ -1,116 +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
+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

{symbol_sdk_python-3.3.0 → symbol_sdk_python-3.3.2}/symbolchain/RuleBasedTransactionFactory.py

@@ -161,6 +161,17 @@ class RuleBasedTransactionFactory:
 
 	@staticmethod
 	def _auto_encode_strings(entity):
+		if not hasattr(entity, '__dict__'):  # skip non-objects
+			return
+
 		for key, value in vars(entity).items():
+			if '_' == key[0] and '_' == key[-1]:  # skip system properties
+				continue
+
 			if isinstance(value, str):
-				setattr(entity, key, value.encode('utf8'))
+				setattr(entity, key, value.encode('utf8'))  # convert string literals to byte array
+			elif hasattr(value, '__len__'):  # process list items
+				for item in value:
+					RuleBasedTransactionFactory._auto_encode_strings(item)
+			else:
+				RuleBasedTransactionFactory._auto_encode_strings(value)  # process nested objects

symbol_sdk_python-3.3.2/symbolchain/nem/FeeCalculator.py

@@ -0,0 +1,94 @@
+import math
+
+from symbolchain.nc import TransactionType
+
+
+def calculate_mosaic_rental_fee():
+	"""Calculates the minimum required mosaic rental fee."""
+
+	return 10 * 1_000_000
+
+
+def calculate_namespace_rental_fee(is_root):
+	"""
+	Calculates the minimum required namespace rental fee.
+	When is_root is True, calculates the root namespace fee.
+	Otherwise, calculates the child namespace fee.
+	"""
+
+	return (100 if is_root else 10) * 1_000_000
+
+
+def _decode_mosaic_id(mosaic_id):
+	return {'namespace_id': {'name': mosaic_id.namespace_id.name.decode('utf8')}, 'name': mosaic_id.name.decode('utf8')}
+
+
+def _calculate_unweighted_transfer_fee(transaction, mosaic_information_lookup):
+	xem_supply = 8_999_999_999
+	max_mosaic_units = 9_000_000_000_000_000
+
+	def _calculate_xem_transfer_fee(amount):
+		return int(min(25, max(1, amount // 10000)))
+
+	def _calculate_mosaic_total_quantity(mosaic_information):
+		return mosaic_information['supply'] * (10 ** mosaic_information['divisibility'])
+
+	def _calculate_xem_equivalent(amount, mosaic_amount, mosaic_information):
+		if 0 == mosaic_information['supply']:
+			return 0
+
+		# amount          XEM whole units
+		# mosaic_amount   mosaic atomic units
+		# xem_supply / _calculate_mosaic_total_quantity(mosaic_information)  convert mosaic_amount from mosaic units to XEM equivalent units
+		return amount * mosaic_amount * xem_supply / _calculate_mosaic_total_quantity(mosaic_information)
+
+	def _calculate_mosaic_transfer_fee(amount, mosaic, mosaic_information):
+		if 0 == mosaic_information['divisibility'] and 10_000 >= mosaic_information['supply']:
+			return 1
+
+		xem_equivalent = _calculate_xem_equivalent(amount, mosaic.mosaic.amount.value, mosaic_information)
+		xem_fee = _calculate_xem_transfer_fee(xem_equivalent)
+		mosaic_total_quantity = _calculate_mosaic_total_quantity(mosaic_information)
+		supply_related_adjustment = 0 if 0 == mosaic_total_quantity else int(0.8 * math.log(max_mosaic_units / mosaic_total_quantity))
+		return max(1, xem_fee - supply_related_adjustment)
+
+	message_fee = 0 if not transaction.message else len(transaction.message.message) // 32 + 1
+	amount = transaction.amount.value // 1_000_000  # convert to XEM whole units
+	if not transaction.mosaics:
+		transfer_fee = _calculate_xem_transfer_fee(amount)
+		return message_fee + transfer_fee
+
+	def _lookup_and_calculate_mosaic_transfer_fee(mosaic):
+		mosaic_id = _decode_mosaic_id(mosaic.mosaic.mosaic_id)
+		mosaic_information = mosaic_information_lookup(mosaic_id)
+		if not mosaic_information:
+			raise ValueError(f'unable to find fee information for {mosaic_id["namespace_id"]["name"]}:{mosaic_id["name"]}')
+
+		return _calculate_mosaic_transfer_fee(amount, mosaic, mosaic_information)
+
+	transfer_fee = sum(_lookup_and_calculate_mosaic_transfer_fee(mosaic) for mosaic in transaction.mosaics)
+	return message_fee + transfer_fee
+
+
+def calculate_transaction_fee(transaction, mosaic_information_lookup=None):
+	"""
+	Calculates the minimum required transaction fee for a transaction.
+	mosaic_information_lookup looks up mosaic information ({supply, divisibility}) given mosaic identifier.
+	When a function, mosaic identifier will be passed as parameter.
+	When an object map, fully qualified mosaic identifier will be used as an index.
+	When None, this function will be unable to calculate fees for custom mosaic transfers.
+	"""
+
+	def _weight_with_fee_unit(amount):
+		return amount * 50_000
+
+	if TransactionType.TRANSFER != transaction.type_:
+		return _weight_with_fee_unit(10 if TransactionType.MULTISIG_ACCOUNT_MODIFICATION == transaction.type_ else 3)
+
+	def _make_lookup_function(lookup):
+		if callable(lookup):
+			return lookup
+
+		return lambda mosaic_id: lookup[f'{mosaic_id["namespace_id"]["name"]}:{mosaic_id["name"]}']
+
+	return _weight_with_fee_unit(_calculate_unweighted_transfer_fee(transaction, _make_lookup_function(mosaic_information_lookup)))

{symbol_sdk_python-3.3.0 → symbol_sdk_python-3.3.2}/symbolchain/nem/TransactionFactory.py

@@ -33,10 +33,6 @@ class TransactionFactory:
 		if autosort:
 			transaction.sort()
 
-		# hack: explicitly translate transfer message
-		if nc.TransactionType.TRANSFER == transaction.type_ and transaction.message and isinstance(transaction.message.message, str):
-			transaction.message.message = transaction.message.message.encode('utf8')
-
 		return transaction
 
 	@staticmethod
@@ -66,9 +62,13 @@ class TransactionFactory:
 	def attach_signature(transaction, signature):
 		"""Attaches a signature to a transaction."""
 		transaction.signature = nc.Signature(signature.bytes)
+		return TransactionFactory.to_json(transaction)
 
+	@staticmethod
+	def to_json(transaction):
+		"""Generates a JSON representation of transaction that can be sent to a node."""
 		transaction_hex = hexlify(TransactionFactory.to_non_verifiable_transaction(transaction).serialize()).decode('utf8').upper()
-		signature_hex = str(signature)
+		signature_hex = str(transaction.signature)
 		json_payload = f'{{"data":"{transaction_hex}", "signature":"{signature_hex}"}}'
 		return json_payload
 

symbol_sdk_python-3.3.2/symbolchain/symbol/FeeCalculator.py

@@ -0,0 +1,7 @@
+from symbolchain.sc import Cosignature
+
+
+def calculate_transaction_fee(transaction, fee_multiplier, cosignature_count=0):
+	"""Calculates the minimum required transaction fee for a transaction."""
+
+	return transaction.size * fee_multiplier + Cosignature().size * cosignature_count

{symbol_sdk_python-3.3.0 → symbol_sdk_python-3.3.2}/symbolchain/symbol/IdGenerator.py

@@ -19,6 +19,9 @@ def generate_mosaic_id(owner_address, nonce):
 
 def generate_namespace_id(name, parent_namespace_id=0):
 	"""Generates a namespace id from a name and an optional parent namespace id."""
+	if '.' in name:
+		raise ValueError(f'\'name\' cannot contain \'.\'; if {name} is a namepace path, consider using generate_namespace_path')
+
 	hasher = hashlib.sha3_256()
 	hasher.update(parent_namespace_id.to_bytes(8, 'little'))
 	hasher.update(name.encode('utf8'))
@@ -33,6 +36,11 @@ def generate_mosaic_alias_id(fully_qualified_name):
 	return generate_namespace_path(fully_qualified_name)[-1]
 
 
+def is_mosaic_alias(mosaic_id):
+	"""Determines if mosaic_id is an alias."""
+	return 0 != (mosaic_id & NAMESPACE_FLAG)
+
+
 def is_valid_namespace_name(name):
 	"""Returns true if a name is a valid namespace name."""
 	def is_alphanum(character):

{symbol_sdk_python-3.3.0 → symbol_sdk_python-3.3.2}/symbolchain/symbol/Network.py

@@ -41,11 +41,16 @@ class Address(ByteArray):
 	def to_namespace_id(self):
 		"""Attempts to convert this address into a namespace id."""
 
-		if not self.bytes[0] & 0x01:
+		if not self.is_alias():
 			return None
 
 		return NamespaceId(int.from_bytes(self.bytes[1:9], 'little'))
 
+	def is_alias(self):
+		"""Determines if this address is an alias."""
+
+		return 0 != (self.bytes[0] & 0x01)
+
 	def __str__(self):
 		return base64.b32encode(self.bytes + bytes(0)).decode('utf8')[0:-1]
 

symbol_sdk_python-3.3.2/symbolchain/symbol/Restriction.py

@@ -0,0 +1,10 @@
+import hashlib
+
+
+def mosaic_restriction_generate_key(seed):
+	"""Generates a mosaic restriction key from a string."""
+
+	hash_result = hashlib.sha3_256(seed.encode('utf8')).digest()
+	key_bytes = bytearray(hash_result[:8])
+
+	return int.from_bytes(key_bytes, 'little')

{symbol_sdk_python-3.3.0 → symbol_sdk_python-3.3.2}/symbolchain/symbol/TransactionFactory.py

@@ -69,7 +69,11 @@ class TransactionFactory:
 	def attach_signature(transaction, signature):
 		"""Attaches a signature to a transaction."""
 		transaction.signature = sc.Signature(signature.bytes)
+		return TransactionFactory.to_json(transaction)
 
+	@staticmethod
+	def to_json(transaction):
+		"""Generates a JSON representation of transaction that can be sent to a node."""
 		transaction_buffer = transaction.serialize()
 		hex_payload = hexlify(transaction_buffer).decode('utf8').upper()
 		json_payload = f'{{"payload": "{hex_payload}"}}'