symbol-sdk-python 3.2.0__tar.gz → 3.2.3__tar.gz

{symbol_sdk_python-3.2.0 → symbol_sdk_python-3.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: symbol-sdk-python
-Version: 3.2.0
+Version: 3.2.3
 Summary: Symbol SDK
 Home-page: https://github.com/symbol/symbol/tree/main/sdk/python
 License: MIT
@@ -9,19 +9,19 @@ Author: Symbol Contributors
 Author-email: contributors@symbol.dev
 Maintainer: Symbol Contributors
 Maintainer-email: contributors@symbol.dev
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.9.2,<4.0.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: cryptography (>=42.0.2,<42.1.0)
+Classifier: Programming Language :: Python :: 3.9
+Requires-Dist: cryptography (>=44.0.0,<44.1.0)
 Requires-Dist: mnemonic (>=0.20,<1.0)
-Requires-Dist: pillow (>=10.3.0,<10.4.0)
+Requires-Dist: pillow (>=11.0.0,<11.1.0)
 Requires-Dist: pynacl (>=1.5.0,<1.6.0)
 Requires-Dist: pyyaml (>=6.0.1,<6.1.0)
 Requires-Dist: pyzbar (>=0.1.9,<0.2.0)
-Requires-Dist: qrcode (>=7.4.2,<7.5.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/symbol/symbol/tree/main/sdk/python

{symbol_sdk_python-3.2.0 → symbol_sdk_python-3.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = 'symbol-sdk-python'
-version = '3.2.0'
+version = '3.2.3'
 description = 'Symbol SDK'
 authors = ['Symbol Contributors <contributors@symbol.dev>']
 maintainers = ['Symbol Contributors <contributors@symbol.dev>']
@@ -17,13 +17,13 @@ keywords = ['symbol', 'sdk', 'Symbol SDK']
 classifiers = ['Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11']
 
 [tool.poetry.dependencies]
-python = "^3.9"
-cryptography = ">=42.0.2,<42.1.0"
+python = "^3.9.2"
+cryptography = ">=44.0.0,<44.1.0"
 mnemonic = ">=0.20,<1.0"
-pillow = ">=10.3.0,<10.4.0"
+pillow = ">=11.0.0,<11.1.0"
 pynacl = ">=1.5.0,<1.6.0"
 pyyaml = ">=6.0.1,<6.1.0"
 pyzbar = ">=0.1.9,<0.2.0"
-qrcode = ">=7.4.2,<7.5.0"
+qrcode = ">=8.0,<9.0"
 ripemd-hash = ">=1.0.1,<1.1.0"
 safe-pysha3 = ">=1.0.4,<1.1.0"

{symbol_sdk_python-3.2.0 → symbol_sdk_python-3.2.3}/symbolchain/BaseValue.py

@@ -49,3 +49,7 @@ class BaseValue(Ordered):
 			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

{symbol_sdk_python-3.2.0 → symbol_sdk_python-3.2.3}/symbolchain/ByteArray.py

@@ -37,3 +37,7 @@ class ByteArray(Ordered):
 
 	def __str__(self):
 		return hexlify(self.bytes).decode('utf8').upper()
+
+	def to_json(self):
+		"""Returns representation of this object that can be stored in JSON."""
+		return str(self)

{symbol_sdk_python-3.2.0 → symbol_sdk_python-3.2.3}/symbolchain/Network.py

@@ -9,7 +9,7 @@ class Network:
 	"""Represents a network."""
 
 	def __init__(self, name, identifier, datetime_converter, address_class, network_timestamp_class):
-		# pylint: disable=too-many-arguments
+		# pylint: disable=too-many-arguments,too-many-positional-arguments
 
 		"""Creates a new network with the specified properties."""
 		self.name = name

{symbol_sdk_python-3.2.0 → symbol_sdk_python-3.2.3}/symbolchain/facade/NemFacade.py

@@ -4,11 +4,43 @@ import sha3
 
 from ..CryptoTypes import Hash256, PrivateKey, PublicKey
 from ..nem.KeyPair import KeyPair, Verifier
+from ..nem.MessageEncoder import MessageEncoder
 from ..nem.Network import Address, Network
 from ..nem.SharedKey import SharedKey
 from ..nem.TransactionFactory import TransactionFactory
 from ..Network import NetworkLocator
 
+# region NemPublicAccount / NemAccount
+
+
+class NemPublicAccount:
+	"""NEM public account."""
+
+	def __init__(self, facade, public_key):
+		"""Creates a NEM public account."""
+		self._facade = facade
+		self.public_key = public_key
+		self.address = self._facade.network.public_key_to_address(self.public_key)
+
+
+class NemAccount(NemPublicAccount):
+	"""NEM account."""
+
+	def __init__(self, facade, key_pair):
+		"""Creates a NEM account."""
+		super().__init__(facade, key_pair.public_key)
+		self.key_pair = key_pair
+
+	def message_encoder(self):
+		"""Creates a message encoder that can be used for encrypting and encoding messages between two parties."""
+		return MessageEncoder(self.key_pair)
+
+	def sign_transaction(self, transaction):
+		"""Signs a NEM transaction."""
+		return self._facade.sign_transaction(self.key_pair, transaction)
+
+# endregion
+
 
 class NemFacade:
 	"""Facade used to interact with NEM blockchain."""
@@ -46,6 +78,14 @@ class NemFacade:
 		"""Creates a network timestamp representing the current time."""
 		return self.network.from_datetime(datetime.now(timezone.utc))
 
+	def create_public_account(self, public_key):
+		"""Creates a NEM public account from a public key."""
+		return NemPublicAccount(self, public_key)
+
+	def create_account(self, private_key):
+		"""Creates a NEM account from a private key."""
+		return NemAccount(self, KeyPair(private_key))
+
 	@staticmethod
 	def hash_transaction(transaction):
 		"""Hashes a NEM transaction."""
@@ -53,16 +93,18 @@ class NemFacade:
 		return Hash256(sha3.keccak_256(non_verifiable_transaction.serialize()).digest())
 
 	@staticmethod
-	def sign_transaction(key_pair, transaction):
-		"""Signs a NEM transaction."""
+	def extract_signing_payload(transaction):
+		"""Gets the payload to sign given a NEM transaction."""
 		non_verifiable_transaction = TransactionFactory.to_non_verifiable_transaction(transaction)
-		return key_pair.sign(non_verifiable_transaction.serialize())
+		return non_verifiable_transaction.serialize()
 
-	@staticmethod
-	def verify_transaction(transaction, signature):
+	def sign_transaction(self, key_pair, transaction):
+		"""Signs a NEM transaction."""
+		return key_pair.sign(self.extract_signing_payload(transaction))
+
+	def verify_transaction(self, transaction, signature):
 		"""Verifies a NEM transaction."""
-		non_verifiable_transaction = TransactionFactory.to_non_verifiable_transaction(transaction)
-		return Verifier(transaction.signer_public_key).verify(non_verifiable_transaction.serialize(), signature)
+		return Verifier(transaction.signer_public_key).verify(self.extract_signing_payload(transaction), signature)
 
 	def bip32_path(self, account_id):
 		"""Creates a network compatible BIP32 path for the specified account."""

{symbol_sdk_python-3.2.0 → symbol_sdk_python-3.2.3}/symbolchain/facade/SymbolFacade.py

@@ -6,6 +6,7 @@ from ..CryptoTypes import Hash256, PublicKey, Signature
 from ..Network import NetworkLocator
 from ..symbol.KeyPair import KeyPair, Verifier
 from ..symbol.Merkle import MerkleHashBuilder
+from ..symbol.MessageEncoder import MessageEncoder
 from ..symbol.Network import Address, Network
 from ..symbol.SharedKey import SharedKey
 from ..symbol.TransactionFactory import TransactionFactory
@@ -26,6 +27,45 @@ AGGREGATE_HASHED_SIZE = sum(field[1] for field in [
 ])
 
 
+# region SymbolPublicAccount / SymbolAccount
+
+class SymbolPublicAccount:
+	"""Symbol public account."""
+
+	def __init__(self, facade, public_key):
+		"""Creates a Symbol public account."""
+		self._facade = facade
+		self.public_key = public_key
+		self.address = self._facade.network.public_key_to_address(self.public_key)
+
+
+class SymbolAccount(SymbolPublicAccount):
+	"""Symbol account."""
+
+	def __init__(self, facade, key_pair):
+		"""Creates a Symbol account."""
+		super().__init__(facade, key_pair.public_key)
+		self.key_pair = key_pair
+
+	def message_encoder(self):
+		"""Creates a message encoder that can be used for encrypting and encoding messages between two parties."""
+		return MessageEncoder(self.key_pair)
+
+	def sign_transaction(self, transaction):
+		"""Signs a Symbol transaction."""
+		return self._facade.sign_transaction(self.key_pair, transaction)
+
+	def cosign_transaction(self, transaction, detached=False):
+		"""Cosigns a Symbol transaction."""
+		return self._facade.cosign_transaction(self.key_pair, transaction, detached)
+
+	def cosign_transaction_hash(self, transaction_hash, detached=False):
+		"""Cosigns a Symbol transaction hash."""
+		return self._facade.cosign_transaction_hash(self.key_pair, transaction_hash, detached)
+
+# endregion
+
+
 class SymbolFacade:
 	"""Facade used to interact with Symbol blockchain."""
 
@@ -63,6 +103,14 @@ class SymbolFacade:
 		"""Creates a network timestamp representing the current time."""
 		return self.network.from_datetime(datetime.now(timezone.utc))
 
+	def create_public_account(self, public_key):
+		"""Creates a Symbol public account from a public key."""
+		return SymbolPublicAccount(self, public_key)
+
+	def create_account(self, private_key):
+		"""Creates a Symbol account from a private key."""
+		return SymbolAccount(self, KeyPair(private_key))
+
 	def hash_transaction(self, transaction):
 		"""Hashes a Symbol transaction."""
 		hasher = hashlib.sha3_256()
@@ -72,22 +120,23 @@ class SymbolFacade:
 		hasher.update(self._transaction_data_buffer(transaction.serialize()))
 		return Hash256(hasher.digest())
 
-	def sign_transaction(self, key_pair, transaction):
-		"""Signs a Symbol transaction."""
+	def extract_signing_payload(self, transaction):
+		"""Gets the payload to sign given a Symbol transaction."""
 		sign_buffer = self.network.generation_hash_seed.bytes
 		sign_buffer += self._transaction_data_buffer(transaction.serialize())
-		return key_pair.sign(sign_buffer)
+		return sign_buffer
+
+	def sign_transaction(self, key_pair, transaction):
+		"""Signs a Symbol transaction."""
+		return key_pair.sign(self.extract_signing_payload(transaction))
 
 	def verify_transaction(self, transaction, signature):
 		"""Verifies a Symbol transaction."""
-		verify_buffer = self.network.generation_hash_seed.bytes
-		verify_buffer += self._transaction_data_buffer(transaction.serialize())
-		return Verifier(transaction.signer_public_key).verify(verify_buffer, signature)
-
-	def cosign_transaction(self, key_pair, transaction, detached=False):
-		"""Cosigns a Symbol transaction."""
-		transaction_hash = self.hash_transaction(transaction)
+		return Verifier(transaction.signer_public_key).verify(self.extract_signing_payload(transaction), signature)
 
+	@staticmethod
+	def cosign_transaction_hash(key_pair, transaction_hash, detached=False):
+		"""Cosigns a Symbol transaction hash."""
 		cosignature = sc.DetachedCosignature() if detached else sc.Cosignature()
 		if detached:
 			cosignature.parent_hash = sc.Hash256(transaction_hash.bytes)
@@ -97,6 +146,11 @@ class SymbolFacade:
 		cosignature.signature = sc.Signature(key_pair.sign(transaction_hash.bytes).bytes)
 		return cosignature
 
+	def cosign_transaction(self, key_pair, transaction, detached=False):
+		"""Cosigns a Symbol transaction."""
+		transaction_hash = self.hash_transaction(transaction)
+		return self.cosign_transaction_hash(key_pair, transaction_hash, detached)
+
 	@staticmethod
 	def hash_embedded_transactions(embedded_transactions):
 		"""Hashes embedded transactions of an aggregate."""