symbol-sdk-python 3.3.1__py3-none-any.whl → 3.3.2__py3-none-any.whl

{symbol_sdk_python-3.3.1.dist-info → symbol_sdk_python-3.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: symbol-sdk-python
-Version: 3.3.1
+Version: 3.3.2
 Summary: Symbol SDK
 Home-page: https://github.com/symbol/symbol/tree/main/sdk/python
 License: MIT
@@ -17,7 +17,7 @@ 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 (>=46.0.1,<46.1.0)
+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)

{symbol_sdk_python-3.3.1.dist-info → symbol_sdk_python-3.3.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 symbolchain/AccountDescriptorRepository.py,sha256=XCIIt6XvxqClQL0R7_-xyFBhb0q9bIUbNTr5-YS5f1o,2508
-symbolchain/ArrayHelpers.py,sha256=Iu5QqlWW5j_6Qd0oTFO41MfDH_mKwQLT7XeD2frU2mw,3728
+symbolchain/ArrayHelpers.py,sha256=AI3zBv4KKyJ4gxzAFwRgKNVVUs38PxJEn36SKpmTIaI,3612
 symbolchain/BaseValue.py,sha256=vc56rclpJtxYIL6Mvo6KWwnA0pUfhtsB71NSEjobQtc,1636
 symbolchain/Bip32.py,sha256=L8Fs0XTERGWSPX972KUn-AOPwAS2gZMdVTKAq4HOGa8,1787
 symbolchain/BlockchainSettings.py,sha256=uRHHxi0gW_U9LFUhoDpNMTe2CobLNJQwE9ZMy2o1aX8,723
@@ -17,7 +17,7 @@ symbolchain/Ordered.py,sha256=--tQ_aZpXhZYcsRLgMjUNHPYlAH7BMfuss2CSxMvNhY,397
 symbolchain/PrivateKeyStorage.py,sha256=dACQnqY1nDtNbfItdrG1iyqbnNnEv8G_sntDCD5crs8,1606
 symbolchain/QrSignatureStorage.py,sha256=-KM2QdzkBwOrydxyTLttdDBcZ4vk0O-gwZ51PWdwEDQ,1348
 symbolchain/QrStorage.py,sha256=ch1XsJ-zkZ27hYd_I_ZfChuIyp-k41R3tbTb8LHy6Ik,1494
-symbolchain/RuleBasedTransactionFactory.py,sha256=a07brGtzujd3I_DDAiQmprgh4a-hoEET2SjMGX-Pphk,5101
+symbolchain/RuleBasedTransactionFactory.py,sha256=Bd-b3DFmTeEuZrTKwKHGO7Y38FnlfHt65TEEcF3kNRI,5526
 symbolchain/SharedKey.py,sha256=cnVwHLznU7RKcqhxDcLc9QfRwSHI9Fm9tzanSjsnQsQ,593
 symbolchain/TransactionDescriptorProcessor.py,sha256=XeEuWs8EFGKV8SBDm_tG9KWMjWMsvL8G4PHJrTl57uE,1806
 symbolchain/Transforms.py,sha256=NtSWiq3ntvylwq1VoQ4S1OIeNnVOBekWDK-Vf2uo-ZI,226
@@ -31,14 +31,16 @@ symbolchain/facade/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 symbolchain/impl/CipherHelpers.py,sha256=KSYH95oie-PxFfGAYfnqHOC1RWIrdxC7Vp6Go-o469Q,2152
 symbolchain/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 symbolchain/nc/__init__.py,sha256=ROTctT787pDzqlnJkavy5vAmVe_JLUwj5e9GprFklXM,121192
+symbolchain/nem/FeeCalculator.py,sha256=EnQinmAivWVEIaidLDhkx8TiHYvGEDoNt7xMSIekV_8,3860
 symbolchain/nem/KeyPair.py,sha256=34VwU7EdroB0nnzTCdTEUAK_DMrcDYzo3JKdniXQMG4,3712
 symbolchain/nem/MessageEncoder.py,sha256=EGm4mtmyXUXQb-R49Xmrl3w40ye_LbZQ8r5aJusH0WE,2699
 symbolchain/nem/Network.py,sha256=vD7YEqJHyUPK14UAGBT29cX9Cjvq1uHDfeiYudaxgAw,1746
 symbolchain/nem/SharedKey.py,sha256=owBUV_XNo1wCby0b4Amz1Bl6uzTeQmiSFy7UcWFo00I,1094
-symbolchain/nem/TransactionFactory.py,sha256=m20mHdIhX7b6uxwO__UuyuSL_onw8B42_49dSMgvr4M,4356
+symbolchain/nem/TransactionFactory.py,sha256=UKc54dTiT7Q8jYcIOWcv0uT1bkE_05okevY_nnx4xDE,4103
 symbolchain/nem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 symbolchain/ripemd160.py,sha256=u2uv8wJY5FY8tll_EfiGE5o65Ri6E-8HbynvJUPBJa8,429
 symbolchain/sc/__init__.py,sha256=Po_ezk7y9Rr_xESvHExyq420FRro5un2KvSnojVf3hg,317964
+symbolchain/symbol/FeeCalculator.py,sha256=BmWjyGZeAJEW6LJpT2l8aXQcB4KongfKtzQ6CvO1k-0,280
 symbolchain/symbol/IdGenerator.py,sha256=_QCFDtdVrrlEpT7PEOtCtcv-WaLbyi7rg0F9M1JRRNk,1957
 symbolchain/symbol/KeyPair.py,sha256=CkQh7oOeVRbjKewTfln0t1PZckcTuIXb2roY1zZjVrc,1506
 symbolchain/symbol/Merkle.py,sha256=FrCwnveXEoXEx7xFP4UC_htjAVuVeUNbvnh8YDdy3z0,7243
@@ -50,6 +52,6 @@ symbolchain/symbol/SharedKey.py,sha256=Bg1qYW_iMNYKtokep5S1m9b7GfywM5OGaCrVUdt01
 symbolchain/symbol/TransactionFactory.py,sha256=YkQC2yBI5pSuSTc7-Aivh9kIKt32-Ho9XYWbbye2syw,4131
 symbolchain/symbol/VotingKeysGenerator.py,sha256=tuJ6yl2CqqQ9uupAw3z-GJIW20WOsblcLQb2_fPUCDE,1686
 symbolchain/symbol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-symbol_sdk_python-3.3.1.dist-info/METADATA,sha256=BcOmBmowQbPXsPrXXAIo8P0xPIgBZBXCSKd_ISwu18w,5707
-symbol_sdk_python-3.3.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-symbol_sdk_python-3.3.1.dist-info/RECORD,,
+symbol_sdk_python-3.3.2.dist-info/METADATA,sha256=uFFkPwbCBMS07zX1E3xPmtuH6s_y3fOIPSzFY368EdA,5707
+symbol_sdk_python-3.3.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+symbol_sdk_python-3.3.2.dist-info/RECORD,,

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

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

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)))

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

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