diff --git a/src/hiero_sdk_python/tokens/supply_type.py b/src/hiero_sdk_python/tokens/supply_type.py index 7cb910744..79dbe64af 100644 --- a/src/hiero_sdk_python/tokens/supply_type.py +++ b/src/hiero_sdk_python/tokens/supply_type.py @@ -10,6 +10,8 @@ from enum import Enum +from hiero_sdk_python.hapi.services import basic_types_pb2 + class SupplyType(Enum): """ @@ -21,3 +23,13 @@ class SupplyType(Enum): INFINITE = 0 FINITE = 1 + + @staticmethod + def _from_proto(proto: basic_types_pb2.TokenSupplyType) -> SupplyType: + """Create token supply type from prorobuf message.""" + if proto == basic_types_pb2.TokenSupplyType.FINITE: + return SupplyType.FINITE + if proto == basic_types_pb2.TokenSupplyType.INFINITE: + return SupplyType.INFINITE + + raise ValueError(f"Invalid SupplyType: {proto}") diff --git a/src/hiero_sdk_python/tokens/token_create_transaction.py b/src/hiero_sdk_python/tokens/token_create_transaction.py index 43ef0aaf0..8d1cbd1d7 100644 --- a/src/hiero_sdk_python/tokens/token_create_transaction.py +++ b/src/hiero_sdk_python/tokens/token_create_transaction.py @@ -458,3 +458,58 @@ def build_scheduled_body(self) -> SchedulableTransactionBody: def _get_method(self, channel: _Channel) -> _Method: return _Method(transaction_func=channel.token.createToken, query_func=None) + + @classmethod + def _from_protobuf(cls, transaction_body: transaction_pb2.TransactionBody) -> TokenCreateTransaction: + """Create token create transaction transaction from protobuf message.""" + transaction = super()._from_protobuf(transaction_body) + + if transaction_body.HasField("tokenCreation"): + proto_body = transaction_body.tokenCreation + token_params = TokenParams( + token_name=proto_body.name, + token_symbol=proto_body.symbol, + decimals=proto_body.decimals, + initial_supply=proto_body.initialSupply, + treasury_account_id=( + AccountId._from_proto(proto_body.treasury) + if proto_body.HasField("treasury") + else AccountId(0, 0, 1) + ), + freeze_default=proto_body.freezeDefault, + expiration_time=Timestamp._from_protobuf(proto_body.expiry) if proto_body.HasField("expiry") else None, + auto_renew_account_id=( + AccountId._from_proto(proto_body.autoRenewAccount) + if proto_body.HasField("autoRenewAccount") + else None + ), + auto_renew_period=( + Duration._from_proto(proto_body.autoRenewPeriod) if proto_body.HasField("autoRenewPeriod") else None + ), + memo=proto_body.memo, + token_type=TokenType._from_proto(proto_body.tokenType), + supply_type=SupplyType._from_proto(proto_body.supplyType), + max_supply=proto_body.maxSupply, + metadata=proto_body.metadata, + custom_fees=[CustomFee._from_proto(fee) for fee in proto_body.custom_fees], + ) + + keys = TokenKeys( + admin_key=Key.from_proto_key(proto_body.adminKey) if proto_body.HasField("adminKey") else None, + kyc_key=Key.from_proto_key(proto_body.kycKey) if proto_body.HasField("kycKey") else None, + freeze_key=Key.from_proto_key(proto_body.freezeKey) if proto_body.HasField("freezeKey") else None, + wipe_key=Key.from_proto_key(proto_body.wipeKey) if proto_body.HasField("wipeKey") else None, + supply_key=Key.from_proto_key(proto_body.supplyKey) if proto_body.HasField("supplyKey") else None, + fee_schedule_key=( + Key.from_proto_key(proto_body.fee_schedule_key) if proto_body.HasField("fee_schedule_key") else None + ), + metadata_key=( + Key.from_proto_key(proto_body.metadata_key) if proto_body.HasField("metadata_key") else None + ), + pause_key=Key.from_proto_key(proto_body.pause_key) if proto_body.HasField("pause_key") else None, + ) + + transaction._token_params = token_params + transaction._keys = keys + + return transaction diff --git a/src/hiero_sdk_python/tokens/token_delete_transaction.py b/src/hiero_sdk_python/tokens/token_delete_transaction.py index b03169c36..c2c129e4c 100644 --- a/src/hiero_sdk_python/tokens/token_delete_transaction.py +++ b/src/hiero_sdk_python/tokens/token_delete_transaction.py @@ -94,3 +94,15 @@ def build_scheduled_body(self) -> SchedulableTransactionBody: def _get_method(self, channel: _Channel) -> _Method: return _Method(transaction_func=channel.token.deleteToken, query_func=None) + + @classmethod + def _from_protobuf(cls, transaction_body: transaction_pb2.TransactionBody) -> TokenDeleteTransaction: + """Create token delete transaction from protobuf message.""" + transaction = super()._from_protobuf(transaction_body) + + if transaction_body.HasField("tokenDeletion"): + proto_body = transaction_body.tokenDeletion + if proto_body.HasField("token"): + transaction.token_id = TokenId._from_proto(proto_body.token) + + return transaction diff --git a/src/hiero_sdk_python/tokens/token_fee_schedule_update_transaction.py b/src/hiero_sdk_python/tokens/token_fee_schedule_update_transaction.py index 4b4a9de50..320334a8b 100644 --- a/src/hiero_sdk_python/tokens/token_fee_schedule_update_transaction.py +++ b/src/hiero_sdk_python/tokens/token_fee_schedule_update_transaction.py @@ -92,3 +92,18 @@ def _get_method(self, channel: _Channel) -> _Method: def __repr__(self): """Readable representation for debugging.""" return f"" + + @classmethod + def _from_protobuf(cls, transaction_body: transaction_pb2.TransactionBody) -> TokenFeeScheduleUpdateTransaction: + """Create token fee schedule update transaction transaction from protobuf message.""" + transaction = super()._from_protobuf(transaction_body) + + if transaction_body.HasField("token_fee_schedule_update"): + proto_body = transaction_body.token_fee_schedule_update + + if proto_body.HasField("token_id"): + transaction.token_id = TokenId._from_proto(proto_body.token_id) + + transaction.custom_fees = [CustomFee._from_proto(fee) for fee in proto_body.custom_fees] + + return transaction diff --git a/src/hiero_sdk_python/tokens/token_type.py b/src/hiero_sdk_python/tokens/token_type.py index 3a06c194c..7a618c156 100644 --- a/src/hiero_sdk_python/tokens/token_type.py +++ b/src/hiero_sdk_python/tokens/token_type.py @@ -10,6 +10,8 @@ from enum import Enum +from hiero_sdk_python.hapi.services import basic_types_pb2 + class TokenType(Enum): """ @@ -44,3 +46,13 @@ class TokenType(Enum): FUNGIBLE_COMMON = 0 NON_FUNGIBLE_UNIQUE = 1 + + @staticmethod + def _from_proto(proto: basic_types_pb2.TokenType) -> TokenType: + """Create TokenType from protobuf message.""" + if proto == basic_types_pb2.TokenType.FUNGIBLE_COMMON: + return TokenType.FUNGIBLE_COMMON + if proto == basic_types_pb2.TokenType.NON_FUNGIBLE_UNIQUE: + return TokenType.NON_FUNGIBLE_UNIQUE + + raise ValueError(f"Invalid TokenType: {proto}") diff --git a/src/hiero_sdk_python/tokens/token_update_nfts_transaction.py b/src/hiero_sdk_python/tokens/token_update_nfts_transaction.py index f5a90f6c6..8176cae28 100644 --- a/src/hiero_sdk_python/tokens/token_update_nfts_transaction.py +++ b/src/hiero_sdk_python/tokens/token_update_nfts_transaction.py @@ -169,3 +169,21 @@ def _from_proto(self, proto: token_update_nfts_pb2.TokenUpdateNftsTransactionBod self.serial_numbers = list(proto.serial_numbers) self.metadata = proto.metadata.value return self + + @classmethod + def _from_protobuf(cls, transaction_body: transaction_pb2.TransactionBody) -> TokenUpdateNftsTransactionBody: + """Create token update nfts transaction transaction from protobuf message.""" + transaction = super()._from_protobuf(transaction_body) + + if transaction_body.HasField("token_update_nfts"): + proto_body = transaction_body.token_update_nfts + + if proto_body.HasField("token"): + transaction.token_id = TokenId._from_proto(proto_body.token) + + if proto_body.HasField("metadata"): + transaction.metadata = proto_body.metadata.value + + transaction.serial_numbers = [serial for serial in proto_body.serial_numbers] + + return transaction diff --git a/src/hiero_sdk_python/tokens/token_update_transaction.py b/src/hiero_sdk_python/tokens/token_update_transaction.py index 1d6ecb4db..837c65a7b 100644 --- a/src/hiero_sdk_python/tokens/token_update_transaction.py +++ b/src/hiero_sdk_python/tokens/token_update_transaction.py @@ -486,3 +486,50 @@ def _set_keys_to_proto(self, token_update_body: token_update_pb2.TokenUpdateTran token_update_body.kycKey.CopyFrom(key_to_proto(self.kyc_key)) if self.fee_schedule_key: token_update_body.fee_schedule_key.CopyFrom(key_to_proto(self.fee_schedule_key)) + + @classmethod + def _from_protobuf(cls, transaction_body: transaction_pb2.TransactionBody) -> TokenUpdateTransaction: + """Create token create transaction transaction from protobuf message.""" + transaction = super()._from_protobuf(transaction_body) + + if transaction_body.HasField("tokenUpdate"): + proto_body = transaction_body.tokenUpdate + + transaction.token_id = TokenId._from_proto(proto_body.token) if proto_body.HasField("token") else None + transaction.token_symbol = proto_body.symbol + transaction.token_name = proto_body.name + transaction.treasury_account_id = ( + AccountId._from_proto(proto_body.treasury) if proto_body.HasField("treasury") else None + ) + transaction.admin_key = Key.from_proto_key(proto_body.adminKey) if proto_body.HasField("adminKey") else None + transaction.kyc_key = Key.from_proto_key(proto_body.kycKey) if proto_body.HasField("kycKey") else None + transaction.freeze_key = ( + Key.from_proto_key(proto_body.freezeKey) if proto_body.HasField("freezeKey") else None + ) + transaction.wipe_key = Key.from_proto_key(proto_body.wipeKey) if proto_body.HasField("wipeKey") else None + transaction.supply_key = ( + Key.from_proto_key(proto_body.supplyKey) if proto_body.HasField("supplyKey") else None + ) + transaction.auto_renew_account_id = ( + AccountId._from_proto(proto_body.autoRenewAccount) if proto_body.HasField("autoRenewAccount") else None + ) + transaction.auto_renew_period = ( + Duration._from_proto(proto_body.autoRenewPeriod) if proto_body.HasField("autoRenewPeriod") else None + ) + transaction.expiration_time = ( + Timestamp._from_protobuf(proto_body.expiry) if proto_body.HasField("expiry") else None + ) + transaction.token_memo = proto_body.memo.value if proto_body.HasField("memo") else None + transaction.metadata = proto_body.metadata.value if proto_body.HasField("metadata") else None + transaction.fee_schedule_key = ( + Key.from_proto_key(proto_body.fee_schedule_key) if proto_body.HasField("fee_schedule_key") else None + ) + transaction.metadata_key = ( + Key.from_proto_key(proto_body.metadata_key) if proto_body.HasField("metadata_key") else None + ) + transaction.pause_key = ( + Key.from_proto_key(proto_body.pause_key) if proto_body.HasField("pause_key") else None + ) + transaction.token_key_verification_mode = TokenKeyValidation._from_proto(proto_body.key_verification_mode) + + return transaction diff --git a/tests/integration/token_create_transaction_e2e_test.py b/tests/integration/token_create_transaction_e2e_test.py index b245762e4..5d2daf2ba 100644 --- a/tests/integration/token_create_transaction_e2e_test.py +++ b/tests/integration/token_create_transaction_e2e_test.py @@ -10,7 +10,7 @@ from hiero_sdk_python.response_code import ResponseCode from hiero_sdk_python.timestamp import Timestamp from hiero_sdk_python.tokens.custom_fixed_fee import CustomFixedFee -from hiero_sdk_python.tokens.token_create_transaction import TokenCreateTransaction, TokenParams +from hiero_sdk_python.tokens.token_create_transaction import TokenCreateTransaction, TokenKeys, TokenParams from hiero_sdk_python.tokens.token_fee_schedule_update_transaction import TokenFeeScheduleUpdateTransaction from hiero_sdk_python.tokens.token_type import TokenType from hiero_sdk_python.transaction.transaction import Transaction @@ -243,3 +243,59 @@ def test_fungible_token_create_with_metadata(env): token_info = TokenInfoQuery(token_id=token_id).execute(env.client) assert token_info.metadata == metadata, "Token metadata mismatch" + + +@pytest.mark.integration +def test_create_fungible_token_from_bytes(env): + """Test create fungible token using a transaction deserialized from bytes.""" + params = TokenParams( + token_name="Test FT", + token_symbol="TFT", + initial_supply=1, + treasury_account_id=env.client.operator_account_id, + token_type=TokenType.FUNGIBLE_COMMON, + ) + + original_tx = TokenCreateTransaction(params) + copy_tx = TokenCreateTransaction.from_bytes(original_tx.to_bytes()) + + receipt = copy_tx.execute(env.client) + assert receipt.token_id is not None, "TokenID not found in receipt. Token may not have been created." + + token_id = receipt.token_id + + token_info = TokenInfoQuery(token_id=token_id).execute(env.client) + + assert token_info.token_type == TokenType.FUNGIBLE_COMMON, "Token type mismatch" + assert token_info.total_supply == 1, "Token total supply must be equal to 1" + assert token_info.name == "Test FT", "Token name mismatch" + assert token_info.symbol == "TFT", "Token symbol mismatch" + + +@pytest.mark.integration +def test_create_nft_from_bytes(env): + """Test create nft using a transaction deserialized from bytes.""" + params = TokenParams( + token_name="Test NFT", + token_symbol="TNFT", + treasury_account_id=env.client.operator_account_id, + initial_supply=0, + token_type=TokenType.NON_FUNGIBLE_UNIQUE, + ) + + keys = TokenKeys(supply_key=env.operator_key) + + original_tx = TokenCreateTransaction(params, keys) + copy_tx = TokenCreateTransaction.from_bytes(original_tx.to_bytes()) + + receipt = copy_tx.execute(env.client) + assert receipt.token_id is not None, "TokenID not found in receipt. Token may not have been created." + + token_id = receipt.token_id + + token_info = TokenInfoQuery(token_id=token_id).execute(env.client) + + assert token_info.token_type == TokenType.NON_FUNGIBLE_UNIQUE, "Token type mismatch" + assert token_info.total_supply == 0, "Token total supply must be equal to 0" + assert token_info.name == "Test NFT", "Token name mismatch" + assert token_info.symbol == "TNFT", "Token symbol mismatch" diff --git a/tests/integration/token_delete_transaction_e2e_test.py b/tests/integration/token_delete_transaction_e2e_test.py index 886591f5a..88c3eef81 100644 --- a/tests/integration/token_delete_transaction_e2e_test.py +++ b/tests/integration/token_delete_transaction_e2e_test.py @@ -2,6 +2,7 @@ import pytest +from hiero_sdk_python.query.token_info_query import TokenInfoQuery from hiero_sdk_python.response_code import ResponseCode from hiero_sdk_python.tokens.token_delete_transaction import TokenDeleteTransaction from tests.integration.utils import create_fungible_token @@ -20,3 +21,21 @@ def test_integration_token_delete_transaction_can_execute(env): assert receipt.status == ResponseCode.SUCCESS, ( f"Token deletion failed with status: {ResponseCode(receipt.status).name}" ) + + +@pytest.mark.integration +def test_delete_token_from_bytes(env): + """Test delete token transaction can be executed from bytes.""" + token_id = create_fungible_token(env) + assert token_id is not None, "TokenID not found in receipt. Token may not have been created." + + original_tx = TokenDeleteTransaction(token_id=token_id) + copy_tx = TokenDeleteTransaction.from_bytes(original_tx.to_bytes()) + receipt = copy_tx.execute(env.client) + + assert receipt.status == ResponseCode.SUCCESS, ( + f"Token deletion failed with status: {ResponseCode(receipt.status).name}" + ) + + token_info = TokenInfoQuery(token_id=token_id).execute(env.client) + assert token_info.is_deleted is True, "Token must have been deleted" diff --git a/tests/integration/token_fee_schedule_update_transaction_e2e_test.py b/tests/integration/token_fee_schedule_update_transaction_e2e_test.py index bb55245ee..4daf5579c 100644 --- a/tests/integration/token_fee_schedule_update_transaction_e2e_test.py +++ b/tests/integration/token_fee_schedule_update_transaction_e2e_test.py @@ -197,3 +197,35 @@ def test_token_fee_schedule_update_clears_fees(env): token_info_cleared = TokenInfoQuery().set_token_id(token_id).execute(env.client) assert len(token_info_cleared.custom_fees) == 0 + + +@pytest.mark.integration +def test_update_token_fee_schedule_from_bytes(env): + """Test token update fee schedule transaction can be executed from bytes.""" + fee_schedule_key = env.operator_key + token_id = create_fungible_token(env, opts=[lambda tx: tx.set_fee_schedule_key(fee_schedule_key)]) + assert token_id is not None + + new_fee = CustomFixedFee( + amount=25, + fee_collector_account_id=env.operator_id, + ) + original_tx = ( + TokenFeeScheduleUpdateTransaction() + .set_token_id(token_id) + .set_custom_fees([new_fee]) + .freeze_with(env.client) + .sign(fee_schedule_key) + ) + + copy_tx = TokenFeeScheduleUpdateTransaction.from_bytes(original_tx.to_bytes()) + + receipt = copy_tx.execute(env.client) + assert receipt.status == ResponseCode.SUCCESS, f"Fee schedule update failed: {ResponseCode(receipt.status).name}" + + token_info = TokenInfoQuery().set_token_id(token_id).execute(env.client) + assert token_info.custom_fees and len(token_info.custom_fees) == 1, ( + "Custom fee must be present and should have length 1" + ) + retrieved_fee = token_info.custom_fees[0] + assert isinstance(retrieved_fee, CustomFixedFee) and retrieved_fee.amount == 25, "Custom fee amount must be 25" diff --git a/tests/integration/token_update_nfts_transaction_e2e_test.py b/tests/integration/token_update_nfts_transaction_e2e_test.py index c923dea15..0c0e2dd44 100644 --- a/tests/integration/token_update_nfts_transaction_e2e_test.py +++ b/tests/integration/token_update_nfts_transaction_e2e_test.py @@ -263,3 +263,39 @@ def test_token_update_nfts_transaction_fails_for_nonexistent_serial(env): assert receipt.status == ResponseCode.INVALID_NFT_ID, ( f"NFT update should fail with INVALID_NFT_ID, got status: {ResponseCode(receipt.status).name}" ) + + +@pytest.mark.integration +def test_update_nfts_from_bytes(env): + """Test token update nfts transaction can be executed from bytes.""" + supply_private_key = PrivateKey.generate_ed25519() + metadata_private_key = PrivateKey.generate_ed25519() + + nft_id = create_nft_token( + env, [lambda tx: tx.set_supply_key(supply_private_key), lambda tx: tx.set_metadata_key(metadata_private_key)] + ) + + mint_metadata = b"Hello, Hedera" + mint_tx = TokenMintTransaction(token_id=nft_id, metadata=mint_metadata) + receipt = mint_tx.freeze_with(env.client).sign(supply_private_key).execute(env.client) + + assert receipt.status == ResponseCode.SUCCESS, ( + f"NFT minting failed with status: {ResponseCode(receipt.status).name}" + ) + + serials = receipt.serial_numbers + nft_info = TokenNftInfoQuery(NftId(nft_id, serials[0])).execute(env.client) + assert nft_info.metadata == mint_metadata, f"Initial metadata mismatch for serial {serials[0]}" + + updated_metadata = b"Hello, Hiero" + original_update_tx = TokenUpdateNftsTransaction(token_id=nft_id, serial_numbers=serials, metadata=updated_metadata) + original_update_tx.transaction_fee = Hbar(3).to_tinybars() + original_update_tx.freeze_with(env.client).sign(metadata_private_key) + + copy_update_tx = TokenUpdateNftsTransaction.from_bytes(original_update_tx.to_bytes()) + receipt = copy_update_tx.execute(env.client) + + assert receipt.status == ResponseCode.SUCCESS, f"NFT update failed with status: {ResponseCode(receipt.status).name}" + + nft_info = TokenNftInfoQuery(NftId(nft_id, serials[0])).execute(env.client) + assert nft_info.metadata == updated_metadata, f"Updated metadata mismatch for serial {serials[0]}" diff --git a/tests/integration/token_update_transaction_e2e_test.py b/tests/integration/token_update_transaction_e2e_test.py index 22493061b..61df87b1b 100644 --- a/tests/integration/token_update_transaction_e2e_test.py +++ b/tests/integration/token_update_transaction_e2e_test.py @@ -932,3 +932,35 @@ def test_integration_token_update_with_mixed_key_types(env): # Verify supply key (from PublicKey) assert token_info.supply_key.to_bytes_raw() == supply_public_key.to_bytes_raw() + + +@pytest.mark.integration +def test_token_update_from_bytes(env): + """Test token update transaction can be executed from bytes.""" + token_id = create_fungible_token(env) + auto_renew_period = Duration(2592000) + + original_tx = ( + TokenUpdateTransaction() + .set_token_id(token_id) + .set_token_name("UpdatedName") + .set_token_symbol("UPD") + .set_auto_renew_period(auto_renew_period) + .set_freeze_key(private_key) + ) + + copy_tx = TokenUpdateTransaction.from_bytes(original_tx.to_bytes()) + receipt = copy_tx.execute(env.client) + assert receipt.status == ResponseCode.SUCCESS, ( + f"Token update transaction failed with status: {ResponseCode(receipt.status).name}" + ) + + info = TokenInfoQuery().set_token_id(token_id).execute(env.client) + + assert info.name == "UpdatedName", "Token failed to update" + assert info.symbol == "UPD", "Token symbol failed to update" + assert info.auto_renew_period == auto_renew_period, "Token auto_renew_period failed to update" + assert info.freeze_key.to_bytes_raw() == private_key.public_key().to_bytes_raw(), ( + "Freeze key did not update correctly" + ) + assert info.admin_key.to_bytes_raw() == env.public_operator_key.to_bytes_raw(), "Admin key mismatch after update" diff --git a/tests/unit/supply_type_test.py b/tests/unit/supply_type_test.py index 77c91be8a..584d068b5 100644 --- a/tests/unit/supply_type_test.py +++ b/tests/unit/supply_type_test.py @@ -2,6 +2,7 @@ import pytest +from hiero_sdk_python.hapi.services import basic_types_pb2 from hiero_sdk_python.tokens.supply_type import SupplyType @@ -9,17 +10,34 @@ def test_members(): + """Test SupplyType return valid value.""" assert SupplyType.INFINITE.value == 0 assert SupplyType.FINITE.value == 1 def test_name(): + """Test SupplyType return valid name.""" assert SupplyType.INFINITE.name == "INFINITE" assert SupplyType.FINITE.name == "FINITE" def test_supply_type_enum_members(): + """Test the SuppltType can get as list.""" members = list(SupplyType) assert len(members) == 2 assert SupplyType.INFINITE in members assert SupplyType.FINITE in members + + +@pytest.mark.parametrize( + ("proto", "expected"), + [ + (basic_types_pb2.TokenSupplyType.FINITE, SupplyType.FINITE), + (basic_types_pb2.TokenSupplyType.INFINITE, SupplyType.INFINITE), + ], +) +def test_from_proto(proto, expected): + """Test SupplyType creation using protobuf message.""" + supply_type = SupplyType._from_proto(proto) + assert supply_type is not None + assert supply_type == expected diff --git a/tests/unit/token_create_transaction_test.py b/tests/unit/token_create_transaction_test.py index 44f3b0e56..43ea2c2ca 100644 --- a/tests/unit/token_create_transaction_test.py +++ b/tests/unit/token_create_transaction_test.py @@ -33,11 +33,14 @@ from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import ( SchedulableTransactionBody, ) +from hiero_sdk_python.hapi.services.token_create_pb2 import TokenCreateTransactionBody from hiero_sdk_python.query.token_info_query import TokenInfoQuery from hiero_sdk_python.response_code import ResponseCode from hiero_sdk_python.timestamp import Timestamp +from hiero_sdk_python.tokens.custom_fixed_fee import CustomFixedFee from hiero_sdk_python.tokens.supply_type import SupplyType from hiero_sdk_python.tokens.token_create_transaction import ( + AUTO_RENEW_PERIOD, TokenCreateTransaction, TokenKeys, TokenParams, @@ -965,3 +968,235 @@ def test_to_proto_key_wrapper_still_works(): with pytest.raises(TypeError) as e: tx._to_proto_key("this is not a key") assert "Key must be of type PrivateKey or PublicKey" in str(e.value) + + +@pytest.fixture +def token_params(): + return { + "token_name": "Token", + "token_symbol": "TKN", + "treasury_account_id": AccountId.from_string("0.0.101"), + "decimals": 10, + "initial_supply": 1, + "token_type": TokenType.FUNGIBLE_COMMON, + "max_supply": 10, + "supply_type": SupplyType.INFINITE, + "freeze_default": False, + "custom_fees": [CustomFixedFee(amount=15, fee_collector_account_id=AccountId.from_string("0.0.101"))], + "expiration_time": Timestamp(seconds=10, nanos=10), + "auto_renew_account_id": AccountId.from_string("0.0.101"), + "auto_renew_period": Duration(100), + "memo": "Test Token", + "metadata": b"Hello! Hiero", + "key": PrivateKey.generate().public_key(), + } + + +def test_from_protobuf(token_params): + """Test deserialization of TokenCreateTransaction from protobuf with all fields populated.""" + proto = TokenCreateTransactionBody( + name=token_params["token_name"], + symbol=token_params["token_symbol"], + decimals=token_params["decimals"], + initialSupply=token_params["initial_supply"], + treasury=token_params["treasury_account_id"]._to_proto(), + adminKey=token_params["key"].to_proto_key(), + kycKey=token_params["key"].to_proto_key(), + freezeKey=token_params["key"].to_proto_key(), + wipeKey=token_params["key"].to_proto_key(), + supplyKey=token_params["key"].to_proto_key(), + freezeDefault=token_params["freeze_default"], + expiry=token_params["expiration_time"]._to_protobuf(), + autoRenewAccount=token_params["auto_renew_account_id"]._to_proto(), + autoRenewPeriod=token_params["auto_renew_period"]._to_proto(), + memo=token_params["memo"], + tokenType=token_params["token_type"].value, + supplyType=token_params["supply_type"].value, + maxSupply=token_params["max_supply"], + fee_schedule_key=token_params["key"].to_proto_key(), + pause_key=token_params["key"].to_proto_key(), + metadata_key=token_params["key"].to_proto_key(), + metadata=token_params["metadata"], + custom_fees=[fee._to_proto() for fee in token_params["custom_fees"]], + ) + + tx = TokenCreateTransaction._from_protobuf(transaction_pb2.TransactionBody(tokenCreation=proto)) + assert tx is not None + assert isinstance(tx, TokenCreateTransaction) + + params = tx._token_params + keys = tx._keys + assert params.token_name == token_params["token_name"] + assert params.token_symbol == token_params["token_symbol"] + assert params.decimals == token_params["decimals"] + assert params.initial_supply == token_params["initial_supply"] + assert params.treasury_account_id == token_params["treasury_account_id"] + assert params.freeze_default == token_params["freeze_default"] + assert params.expiration_time == token_params["expiration_time"] + assert params.auto_renew_account_id == token_params["auto_renew_account_id"] + assert params.auto_renew_period == token_params["auto_renew_period"] + assert params.memo == token_params["memo"] + assert params.token_type == token_params["token_type"] + assert params.supply_type == token_params["supply_type"] + assert params.max_supply == token_params["max_supply"] + assert params.metadata == token_params["metadata"] + assert params.custom_fees == token_params["custom_fees"] + + assert keys.admin_key == token_params["key"] + assert keys.kyc_key == token_params["key"] + assert keys.freeze_key == token_params["key"] + assert keys.wipe_key == token_params["key"] + assert keys.supply_key == token_params["key"] + assert keys.fee_schedule_key == token_params["key"] + assert keys.pause_key == token_params["key"] + assert keys.metadata_key == token_params["key"] + + +def test_from_protobuf_with_defaults(): + """Test deserialization of TokenCreateTransaction from protobuf with default field values.""" + proto = TokenCreateTransactionBody() + tx = TokenCreateTransaction._from_protobuf(transaction_pb2.TransactionBody(tokenCreation=proto)) + + assert tx is not None + assert isinstance(tx, TokenCreateTransaction) + + params = tx._token_params + keys = tx._keys + assert params.token_name == "" + assert params.token_symbol == "" + assert params.decimals == 0 + assert params.initial_supply == 0 + assert params.treasury_account_id == AccountId(0, 0, 1) + assert params.freeze_default is False + assert params.expiration_time is None + assert params.auto_renew_account_id is None + assert params.auto_renew_period is None + assert params.memo == "" # memo is plain protobuf field. default = "" + assert params.token_type == TokenType.FUNGIBLE_COMMON + assert params.supply_type == SupplyType.INFINITE + assert params.max_supply == 0 + assert params.metadata == b"" # metadata is plain protobuf field. default = b"" + + assert keys.admin_key is None + assert keys.kyc_key is None + assert keys.freeze_key is None + assert keys.wipe_key is None + assert keys.supply_key is None + assert keys.fee_schedule_key is None + assert keys.pause_key is None + assert keys.metadata_key is None + + +def test_from_protobuf_without_token_creation(): + """Test deserialization of TokenCreateTransaction from a TransactionBody without a token update.""" + tx = TokenCreateTransaction._from_protobuf(transaction_pb2.TransactionBody()) + + assert tx is not None + assert isinstance(tx, TokenCreateTransaction) + + params = tx._token_params + keys = tx._keys + assert params.token_name == "" + assert params.token_symbol == "" + assert params.decimals == 0 + assert params.initial_supply == 0 + assert params.treasury_account_id == AccountId(0, 0, 1) + assert params.freeze_default is False + assert params.expiration_time is None + assert params.auto_renew_account_id is None + assert params.auto_renew_period == AUTO_RENEW_PERIOD + assert params.memo is None + assert params.token_type == TokenType.FUNGIBLE_COMMON + assert params.supply_type == SupplyType.INFINITE + assert params.max_supply == 0 + assert params.metadata is None + + assert keys.admin_key is None + assert keys.kyc_key is None + assert keys.freeze_key is None + assert keys.wipe_key is None + assert keys.supply_key is None + assert keys.fee_schedule_key is None + assert keys.pause_key is None + assert keys.metadata_key is None + + +def test_to_bytes_default_values(): + """Test to_bytes generate same bytes for default values.""" + original_tx = TokenCreateTransaction() + original_bytes = original_tx.to_bytes() + + copy_tx = TokenCreateTransaction.from_bytes(original_bytes) + assert copy_tx is not None + assert isinstance(copy_tx, TokenCreateTransaction) + assert copy_tx.to_bytes() == original_bytes + + +def test_bytes_roundtrip(token_params): + """Test serialization and deserialization of TokenCreateTransaction through bytes.""" + params = TokenParams( + token_name=token_params["token_name"], + token_symbol=token_params["token_symbol"], + decimals=token_params["decimals"], + initial_supply=token_params["initial_supply"], + treasury_account_id=token_params["treasury_account_id"], + freeze_default=token_params["freeze_default"], + expiration_time=token_params["expiration_time"], + auto_renew_account_id=token_params["auto_renew_account_id"], + auto_renew_period=token_params["auto_renew_period"], + memo=token_params["memo"], + token_type=token_params["token_type"], + supply_type=token_params["supply_type"], + max_supply=token_params["max_supply"], + metadata=token_params["metadata"], + custom_fees=token_params["custom_fees"], + ) + + keys = TokenKeys( + admin_key=token_params["key"], + kyc_key=token_params["key"], + freeze_key=token_params["key"], + wipe_key=token_params["key"], + supply_key=token_params["key"], + fee_schedule_key=token_params["key"], + pause_key=token_params["key"], + metadata_key=token_params["key"], + ) + + original_tx = TokenCreateTransaction(token_params=params, keys=keys) + original_bytes = original_tx.to_bytes() + + copy_tx = TokenCreateTransaction.from_bytes(original_bytes) + assert copy_tx is not None + assert isinstance(copy_tx, TokenCreateTransaction) + assert copy_tx.to_bytes() == original_bytes + + original_params = original_tx._token_params + original_keys = original_tx._keys + copy_params = copy_tx._token_params + copy_keys = copy_tx._keys + + assert copy_params.token_name == original_params.token_name + assert copy_params.token_symbol == original_params.token_symbol + assert copy_params.decimals == original_params.decimals + assert copy_params.initial_supply == original_params.initial_supply + assert copy_params.treasury_account_id == original_params.treasury_account_id + assert copy_params.freeze_default == original_params.freeze_default + assert copy_params.expiration_time == original_params.expiration_time + assert copy_params.auto_renew_account_id == original_params.auto_renew_account_id + assert copy_params.auto_renew_period == original_params.auto_renew_period + assert copy_params.memo == original_params.memo + assert copy_params.token_type == original_params.token_type + assert copy_params.supply_type == original_params.supply_type + assert copy_params.max_supply == original_params.max_supply + assert copy_params.metadata == original_params.metadata + assert copy_params.custom_fees == original_params.custom_fees + + assert copy_keys.admin_key == original_keys.admin_key + assert copy_keys.kyc_key == original_keys.kyc_key + assert copy_keys.freeze_key == original_keys.freeze_key + assert copy_keys.wipe_key == original_keys.wipe_key + assert copy_keys.supply_key == original_keys.supply_key + assert copy_keys.fee_schedule_key == original_keys.fee_schedule_key + assert copy_keys.pause_key == original_keys.pause_key + assert copy_keys.metadata_key == original_keys.metadata_key diff --git a/tests/unit/token_delete_transaction_test.py b/tests/unit/token_delete_transaction_test.py index 075717827..77cb876c0 100644 --- a/tests/unit/token_delete_transaction_test.py +++ b/tests/unit/token_delete_transaction_test.py @@ -8,6 +8,8 @@ from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import ( SchedulableTransactionBody, ) +from hiero_sdk_python.hapi.services.token_delete_pb2 import TokenDeleteTransactionBody +from hiero_sdk_python.hapi.services.transaction_pb2 import TransactionBody from hiero_sdk_python.tokens.token_delete_transaction import TokenDeleteTransaction from hiero_sdk_python.transaction.transaction_id import TransactionId @@ -113,3 +115,45 @@ def test_build_scheduled_body(mock_account_ids): assert isinstance(schedulable_body, SchedulableTransactionBody) assert schedulable_body.HasField("tokenDeletion") assert schedulable_body.tokenDeletion.token == token_id._to_proto() + + +def test_from_protobuf(token_id): + """Test deserialization of TokenDeleteTransaction from protobuf with all fields populated.""" + proto = TokenDeleteTransactionBody(token=token_id._to_proto()) + tx = TokenDeleteTransaction._from_protobuf(TransactionBody(tokenDeletion=proto)) + + assert tx is not None + assert isinstance(tx, TokenDeleteTransaction) + assert tx.token_id == token_id + + +def test_from_protobuf_without_token_id(): + """Test deserialization of TokenDeleteTransaction from protobuf with default field values.""" + proto = TokenDeleteTransactionBody() + tx = TokenDeleteTransaction._from_protobuf(TransactionBody(tokenDeletion=proto)) + + assert tx is not None + assert isinstance(tx, TokenDeleteTransaction) + assert tx.token_id is None + + +def test_from_protobuf_without_token_deletion(): + """Test deserialization of TokenDeleteTransaction from a TransactionBody without a token update.""" + tx = TokenDeleteTransaction._from_protobuf(TransactionBody()) + + assert tx is not None + assert isinstance(tx, TokenDeleteTransaction) + assert tx.token_id is None + + +def test_bytes_roundtrip(token_id): + """Test serialization and deserialization of TokenDeleteTransaction through bytes.""" + original_tx = TokenDeleteTransaction(token_id=token_id) + original_bytes = original_tx.to_bytes() + + copy_tx = TokenDeleteTransaction.from_bytes(original_bytes) + + assert copy_tx is not None + assert isinstance(copy_tx, TokenDeleteTransaction) + assert copy_tx.to_bytes() == original_bytes + assert copy_tx.token_id == original_tx.token_id diff --git a/tests/unit/token_fee_schedule_update_transaction_test.py b/tests/unit/token_fee_schedule_update_transaction_test.py index 780f38927..af938ec85 100644 --- a/tests/unit/token_fee_schedule_update_transaction_test.py +++ b/tests/unit/token_fee_schedule_update_transaction_test.py @@ -3,6 +3,8 @@ import pytest from hiero_sdk_python.account.account_id import AccountId +from hiero_sdk_python.hapi.services.token_fee_schedule_update_pb2 import TokenFeeScheduleUpdateTransactionBody +from hiero_sdk_python.hapi.services.transaction_pb2 import TransactionBody from hiero_sdk_python.tokens.custom_fixed_fee import CustomFixedFee from hiero_sdk_python.tokens.token_fee_schedule_update_transaction import ( TokenFeeScheduleUpdateTransaction, @@ -115,3 +117,78 @@ def test_build_transaction_body_with_empty_custom_fees(mock_account_ids): assert transaction_body.HasField("token_fee_schedule_update") assert transaction_body.token_fee_schedule_update.token_id == token_id._to_proto() assert len(transaction_body.token_fee_schedule_update.custom_fees) == 0 + + +def test_from_protobuf(mock_account_ids): + """Test deserialization of TokenFeeScheduleUpdateTransaction from protobuf with all fields populated.""" + account_id_1, account_id_2, _, token_id, _ = mock_account_ids + custom_fees = [ + CustomFixedFee(amount=15, fee_collector_account_id=account_id_1), + CustomFixedFee(amount=10, fee_collector_account_id=account_id_2), + ] + + proto = TokenFeeScheduleUpdateTransactionBody( + token_id=token_id._to_proto(), custom_fees=[custom_fee._to_proto() for custom_fee in custom_fees] + ) + tx = TokenFeeScheduleUpdateTransaction._from_protobuf(TransactionBody(token_fee_schedule_update=proto)) + + assert tx is not None + assert isinstance(tx, TokenFeeScheduleUpdateTransaction) + assert tx.token_id == token_id + assert len(tx.custom_fees) == len(custom_fees) + for indx, fee in enumerate(custom_fees): + assert tx.custom_fees[indx] == fee + + +def test_from_protobuf_with_defaults(): + """Test deserialization of TokenFeeScheduleUpdateTransaction from protobuf with default field values.""" + proto = TokenFeeScheduleUpdateTransactionBody() + tx = TokenFeeScheduleUpdateTransaction._from_protobuf(TransactionBody(token_fee_schedule_update=proto)) + + assert tx is not None + assert isinstance(tx, TokenFeeScheduleUpdateTransaction) + assert tx.token_id is None + assert tx.custom_fees == [] + + +def test_from_protobuf_without_token_fee_schedule_update(): + """Test deserialization of TokenFeeScheduleUpdateTransaction from a TransactionBody without a token update.""" + tx = TokenFeeScheduleUpdateTransaction._from_protobuf(TransactionBody()) + + assert tx is not None + assert isinstance(tx, TokenFeeScheduleUpdateTransaction) + assert tx.token_id is None + assert tx.custom_fees == [] + + +def test_to_bytes_default_values(): + """Test to_bytes generate same bytes for default values.""" + original_tx = TokenFeeScheduleUpdateTransaction() + original_bytes = original_tx.to_bytes() + + copy_tx = TokenFeeScheduleUpdateTransaction.from_bytes(original_bytes) + assert copy_tx is not None + assert isinstance(copy_tx, TokenFeeScheduleUpdateTransaction) + assert copy_tx.to_bytes() == original_bytes + + +def test_bytes_roundtrip(mock_account_ids): + """Test serialization and deserialization of TokenFeeScheduleUpdateTransaction through bytes.""" + account_id_1, account_id_2, _, token_id, _ = mock_account_ids + custom_fees = [ + CustomFixedFee(amount=15, fee_collector_account_id=account_id_1), + CustomFixedFee(amount=10, fee_collector_account_id=account_id_2), + ] + + original_tx = TokenFeeScheduleUpdateTransaction(token_id=token_id, custom_fees=custom_fees) + original_bytes = original_tx.to_bytes() + + copy_tx = TokenFeeScheduleUpdateTransaction.from_bytes(original_bytes) + + assert copy_tx is not None + assert copy_tx.to_bytes() == original_bytes + assert isinstance(copy_tx, TokenFeeScheduleUpdateTransaction) + assert copy_tx.token_id == token_id + assert len(copy_tx.custom_fees) == len(custom_fees) + for indx, fee in enumerate(custom_fees): + assert copy_tx.custom_fees[indx] == fee diff --git a/tests/unit/token_type_test.py b/tests/unit/token_type_test.py index ed013e681..c81e4c3b8 100644 --- a/tests/unit/token_type_test.py +++ b/tests/unit/token_type_test.py @@ -2,6 +2,7 @@ import pytest +from hiero_sdk_python.hapi.services import basic_types_pb2 from hiero_sdk_python.tokens.token_type import TokenType @@ -9,10 +10,26 @@ def test_members(): + """Test TokenType return valid values.""" assert TokenType.FUNGIBLE_COMMON.value == 0 assert TokenType.NON_FUNGIBLE_UNIQUE.value == 1 def test_name(): + """Test TokeType return valid names.""" assert TokenType.FUNGIBLE_COMMON.name == "FUNGIBLE_COMMON" assert TokenType.NON_FUNGIBLE_UNIQUE.name == "NON_FUNGIBLE_UNIQUE" + + +@pytest.mark.parametrize( + ("proto", "expected"), + [ + (basic_types_pb2.TokenType.FUNGIBLE_COMMON, TokenType.FUNGIBLE_COMMON), + (basic_types_pb2.NON_FUNGIBLE_UNIQUE, TokenType.NON_FUNGIBLE_UNIQUE), + ], +) +def test_from_proto(proto, expected): + """Test TokenType creation using protobuf message.""" + token_type = TokenType._from_proto(proto) + assert token_type is not None + assert token_type == expected diff --git a/tests/unit/token_update_nfts_transaction_test.py b/tests/unit/token_update_nfts_transaction_test.py index e934a8c6f..9034fd870 100644 --- a/tests/unit/token_update_nfts_transaction_test.py +++ b/tests/unit/token_update_nfts_transaction_test.py @@ -8,6 +8,7 @@ SchedulableTransactionBody, ) from hiero_sdk_python.hapi.services.token_update_nfts_pb2 import TokenUpdateNftsTransactionBody +from hiero_sdk_python.hapi.services.transaction_pb2 import TransactionBody from hiero_sdk_python.hapi.services.transaction_receipt_pb2 import TransactionReceipt as TransactionReceiptProto from hiero_sdk_python.hapi.services.transaction_response_pb2 import TransactionResponse as TransactionResponseProto from hiero_sdk_python.response_code import ResponseCode @@ -212,3 +213,60 @@ def test_update_nfts_transaction_from_proto(mock_account_ids): assert isinstance(empty_tx.token_id, TokenId) assert empty_tx.serial_numbers == [] assert empty_tx.metadata is empty_proto.metadata.value # Should be None or empty + + +def test_from_protobuf(token_id): + """Test deserialization of TokenUpdateNftsTransaction from protobuf with all fields populated.""" + serials = [1, 2, 4] + metadata = b"Hello! Hiero" + proto = TokenUpdateNftsTransactionBody( + token=token_id._to_proto(), serial_numbers=serials, metadata=BytesValue(value=metadata) + ) + + tx = TokenUpdateNftsTransaction._from_protobuf(TransactionBody(token_update_nfts=proto)) + assert tx is not None + assert isinstance(tx, TokenUpdateNftsTransaction) + assert tx.token_id == token_id + assert tx.serial_numbers == serials + assert tx.metadata == metadata + + +def test_from_protobuf_with_default_values(): + """Test deserialization of TokenUpdateNftsTransaction from protobuf with default field values.""" + proto = TokenUpdateNftsTransactionBody() + tx = TokenUpdateNftsTransaction._from_protobuf(TransactionBody(token_update_nfts=proto)) + + assert tx is not None + assert isinstance(tx, TokenUpdateNftsTransaction) + assert tx.token_id is None + assert tx.serial_numbers == [] + assert tx.metadata is None + + +def test_from_protobuf_without_token_update_nfts(): + """Test deserialization of TokenUpdateNftsTransaction from a TransactionBody without a token update.""" + tx = TokenUpdateNftsTransaction._from_protobuf(TransactionBody()) + + assert tx is not None + assert isinstance(tx, TokenUpdateNftsTransaction) + assert tx.token_id is None + assert tx.serial_numbers == [] + assert tx.metadata is None + + +def test_bytes_roundtrip(token_id): + """Test serialization and deserialization of TokenUpdateNftsTransaction through bytes.""" + serials = [1, 2, 4] + metadata = b"Hello! Hiero" + + original_tx = TokenUpdateNftsTransaction(token_id=token_id, serial_numbers=serials, metadata=metadata) + original_bytes = original_tx.to_bytes() + + copy_tx = TokenUpdateNftsTransaction.from_bytes(original_bytes) + + assert copy_tx is not None + assert isinstance(copy_tx, TokenUpdateNftsTransaction) + assert copy_tx.to_bytes() == original_bytes + assert copy_tx.token_id == token_id + assert copy_tx.serial_numbers == serials + assert copy_tx.metadata == metadata diff --git a/tests/unit/token_update_transaction_test.py b/tests/unit/token_update_transaction_test.py index 763b64295..0eb8575d5 100644 --- a/tests/unit/token_update_transaction_test.py +++ b/tests/unit/token_update_transaction_test.py @@ -3,19 +3,25 @@ import datetime import pytest +from google.protobuf.wrappers_pb2 import BytesValue, StringValue +from hiero_sdk_python.account.account_id import AccountId from hiero_sdk_python.crypto.private_key import PrivateKey from hiero_sdk_python.crypto.public_key import PublicKey from hiero_sdk_python.Duration import Duration from hiero_sdk_python.hapi.services import response_header_pb2, response_pb2, transaction_get_receipt_pb2 -from hiero_sdk_python.hapi.services.basic_types_pb2 import TokenKeyValidation from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import ( SchedulableTransactionBody, ) +from hiero_sdk_python.hapi.services.token_update_pb2 import TokenUpdateTransactionBody +from hiero_sdk_python.hapi.services.transaction_pb2 import TransactionBody from hiero_sdk_python.hapi.services.transaction_receipt_pb2 import TransactionReceipt as TransactionReceiptProto from hiero_sdk_python.hapi.services.transaction_response_pb2 import TransactionResponse as TransactionResponseProto from hiero_sdk_python.response_code import ResponseCode from hiero_sdk_python.timestamp import Timestamp +from hiero_sdk_python.tokens.custom_fixed_fee import CustomFixedFee +from hiero_sdk_python.tokens.token_id import TokenId +from hiero_sdk_python.tokens.token_key_validation import TokenKeyValidation from hiero_sdk_python.tokens.token_update_transaction import TokenUpdateKeys, TokenUpdateParams, TokenUpdateTransaction from tests.unit.mock_server import mock_hedera_servers @@ -466,3 +472,187 @@ def test_build_transaction_body_with_keys(mock_account_ids, key_type, use_privat assert transaction_body.tokenUpdate.name == new_token_data["name"] verify_key_in_proto(transaction_body.tokenUpdate.adminKey, expected_admin_public, key_type) verify_key_in_proto(transaction_body.tokenUpdate.freezeKey, expected_freeze_public, key_type) + + +@pytest.fixture +def token_params(): + return { + "token_id": TokenId.from_string("0.0.101"), + "token_name": "Token", + "token_symbol": "TKN", + "treasury_account_id": AccountId.from_string("0.0.101"), + "custom_fees": [CustomFixedFee(amount=15, fee_collector_account_id=AccountId.from_string("0.0.101"))], + "expiration_time": Timestamp(seconds=10, nanos=10), + "auto_renew_account_id": AccountId.from_string("0.0.101"), + "auto_renew_period": Duration(100), + "memo": "Test Token", + "metadata": b"Hello! Hiero", + "key_validation": TokenKeyValidation.FULL_VALIDATION, + "key": PrivateKey.generate().public_key(), + } + + +def test_from_protobuf(token_params): + """Test deserialization of TokenUpdateTransaction from protobuf with all fields populated.""" + proto = TokenUpdateTransactionBody( + token=token_params["token_id"]._to_proto(), + symbol=token_params["token_symbol"], + name=token_params["token_name"], + treasury=token_params["treasury_account_id"]._to_proto(), + adminKey=token_params["key"].to_proto_key(), + kycKey=token_params["key"].to_proto_key(), + freezeKey=token_params["key"].to_proto_key(), + wipeKey=token_params["key"].to_proto_key(), + supplyKey=token_params["key"].to_proto_key(), + autoRenewAccount=token_params["auto_renew_account_id"]._to_proto(), + autoRenewPeriod=token_params["auto_renew_period"]._to_proto(), + expiry=token_params["expiration_time"]._to_protobuf(), + memo=StringValue(value=token_params["memo"]), + fee_schedule_key=token_params["key"].to_proto_key(), + pause_key=token_params["key"].to_proto_key(), + metadata=BytesValue(value=token_params["metadata"]), + metadata_key=token_params["key"].to_proto_key(), + key_verification_mode=token_params["key_validation"]._to_proto(), + ) + + tx = TokenUpdateTransaction._from_protobuf(TransactionBody(tokenUpdate=proto)) + assert tx is not None + assert isinstance(tx, TokenUpdateTransaction) + + assert tx.token_id == token_params["token_id"] + assert tx.token_symbol == token_params["token_symbol"] + assert tx.token_name == token_params["token_name"] + assert tx.treasury_account_id == token_params["treasury_account_id"] + assert tx.admin_key == token_params["key"] + assert tx.kyc_key == token_params["key"] + assert tx.freeze_key == token_params["key"] + assert tx.wipe_key == token_params["key"] + assert tx.supply_key == token_params["key"] + assert tx.auto_renew_period == token_params["auto_renew_period"] + assert tx.auto_renew_account_id == token_params["auto_renew_account_id"] + assert tx.expiration_time == token_params["expiration_time"] + assert tx.token_memo == token_params["memo"] + assert tx.fee_schedule_key == token_params["key"] + assert tx.pause_key == token_params["key"] + assert tx.metadata_key == token_params["key"] + assert tx.metadata == token_params["metadata"] + assert tx.token_key_verification_mode == token_params["key_validation"] + + +def test_from_protobuf_with_defaults(): + """Test deserialization of TokenUpdateTransaction from protobuf with default field values.""" + proto = TokenUpdateTransactionBody() + tx = TokenUpdateTransaction._from_protobuf(TransactionBody(tokenUpdate=proto)) + + assert tx is not None + assert isinstance(tx, TokenUpdateTransaction) + + assert tx.token_id is None + assert tx.token_symbol == "" # plain protobuf message field + assert tx.token_name == "" # plain protobuf message field + assert tx.treasury_account_id is None + assert tx.admin_key is None + assert tx.kyc_key is None + assert tx.freeze_key is None + assert tx.wipe_key is None + assert tx.supply_key is None + assert tx.auto_renew_period is None + assert tx.auto_renew_account_id is None + assert tx.expiration_time is None + assert tx.token_memo is None + assert tx.fee_schedule_key is None + assert tx.pause_key is None + assert tx.metadata_key is None + assert tx.metadata is None + assert tx.token_key_verification_mode == TokenKeyValidation.FULL_VALIDATION + + +def test_from_protobuf_without_token_update(): + """Test deserialization of TokenUpdateTransaction from a TransactionBody without a token update.""" + tx = TokenUpdateTransaction._from_protobuf(TransactionBody()) + + assert tx is not None + assert isinstance(tx, TokenUpdateTransaction) + + assert tx.token_id is None + assert tx.token_symbol is None + assert tx.token_name is None + assert tx.treasury_account_id is None + assert tx.admin_key is None + assert tx.kyc_key is None + assert tx.freeze_key is None + assert tx.wipe_key is None + assert tx.supply_key is None + assert tx.auto_renew_period is None + assert tx.auto_renew_account_id is None + assert tx.expiration_time is None + assert tx.token_memo is None + assert tx.fee_schedule_key is None + assert tx.pause_key is None + assert tx.metadata_key is None + assert tx.metadata is None + assert tx.token_key_verification_mode == TokenKeyValidation.FULL_VALIDATION + + +def test_to_bytes_default_values(): + """Test to_bytes generate same bytes for default values.""" + original_tx = TokenUpdateTransaction() + original_bytes = original_tx.to_bytes() + + copy_tx = TokenUpdateTransaction.from_bytes(original_bytes) + assert copy_tx is not None + assert isinstance(copy_tx, TokenUpdateTransaction) + assert copy_tx.to_bytes() == original_bytes + + +def test_bytes_roundtrip(token_params): + """Test serialization and deserialization of TokenUpdateTransaction through bytes.""" + param = TokenUpdateParams( + treasury_account_id=token_params["treasury_account_id"], + token_name=token_params["token_name"], + token_symbol=token_params["token_symbol"], + token_memo=token_params["memo"], + metadata=token_params["metadata"], + auto_renew_period=token_params["auto_renew_period"], + auto_renew_account_id=token_params["auto_renew_account_id"], + expiration_time=token_params["expiration_time"], + ) + + keys = TokenUpdateKeys( + admin_key=token_params["key"], + supply_key=token_params["key"], + freeze_key=token_params["key"], + wipe_key=token_params["key"], + metadata_key=token_params["key"], + pause_key=token_params["key"], + kyc_key=token_params["key"], + fee_schedule_key=token_params["key"], + ) + + original_tx = TokenUpdateTransaction(token_id=token_params["token_id"], token_params=param, token_keys=keys) + original_bytes = original_tx.to_bytes() + + copy_tx = TokenUpdateTransaction.from_bytes(original_bytes) + + assert copy_tx is not None + assert isinstance(copy_tx, TokenUpdateTransaction) + assert copy_tx.to_bytes() == original_bytes + + assert copy_tx.token_id == original_tx.token_id + assert copy_tx.token_symbol == original_tx.token_symbol + assert copy_tx.token_name == original_tx.token_name + assert copy_tx.treasury_account_id == original_tx.treasury_account_id + assert copy_tx.admin_key == original_tx.admin_key + assert copy_tx.kyc_key == original_tx.kyc_key + assert copy_tx.freeze_key == original_tx.freeze_key + assert copy_tx.wipe_key == original_tx.wipe_key + assert copy_tx.supply_key == original_tx.supply_key + assert copy_tx.auto_renew_period == original_tx.auto_renew_period + assert copy_tx.auto_renew_account_id == original_tx.auto_renew_account_id + assert copy_tx.expiration_time == original_tx.expiration_time + assert copy_tx.token_memo == original_tx.token_memo + assert copy_tx.fee_schedule_key == original_tx.fee_schedule_key + assert copy_tx.pause_key == original_tx.pause_key + assert copy_tx.metadata_key == original_tx.metadata_key + assert copy_tx.metadata == original_tx.metadata + assert copy_tx.token_key_verification_mode == original_tx.token_key_verification_mode