test: add targeted coverage for optional _from_protobuf branches to reach 92% patch coverage

Signed-off-by: Mounil Kanakhara <mounilkankhara@gmail.com>

Author: Mounil2005

tests/unit/account_create_transaction_test.py

@@ -577,3 +577,37 @@ def test_from_bytes_without_auto_renew_period(mock_account_ids):
     assert isinstance(reconstructed, AccountCreateTransaction)
     assert reconstructed.initial_balance == 1000
     assert reconstructed.auto_renew_period is None
+
+
+def test_from_bytes_with_staked_account_id(mock_account_ids):
+    """staked_account_id branch in _from_protobuf is covered."""
+    operator_id, node_account_id = mock_account_ids
+
+    tx = AccountCreateTransaction()
+    tx.set_staked_account_id(AccountId(0, 0, 7))
+    tx.transaction_id = generate_transaction_id(operator_id)
+    tx.node_account_id = node_account_id
+    tx.freeze()
+
+    reconstructed = Transaction.from_bytes(tx.to_bytes())
+
+    assert isinstance(reconstructed, AccountCreateTransaction)
+    assert reconstructed.staked_account_id == AccountId(0, 0, 7)
+    assert reconstructed.staked_node_id is None
+
+
+def test_from_bytes_with_staked_node_id(mock_account_ids):
+    """staked_node_id branch in _from_protobuf is covered."""
+    operator_id, node_account_id = mock_account_ids
+
+    tx = AccountCreateTransaction()
+    tx.set_staked_node_id(3)
+    tx.transaction_id = generate_transaction_id(operator_id)
+    tx.node_account_id = node_account_id
+    tx.freeze()
+
+    reconstructed = Transaction.from_bytes(tx.to_bytes())
+
+    assert isinstance(reconstructed, AccountCreateTransaction)
+    assert reconstructed.staked_node_id == 3
+    assert reconstructed.staked_account_id is None

tests/unit/account_update_transaction_test.py

@@ -842,3 +842,28 @@ def test_from_bytes(mock_account_ids):
     assert reconstructed.decline_staking_reward == False
     assert reconstructed.receiver_signature_required == False
     assert reconstructed.max_automatic_token_associations == 10
+
+
+def test_from_bytes_with_key_expiration_and_staked_account(mock_account_ids):
+    """Covers key, expiration_time, and staked_account_id branches in _from_protobuf."""
+    operator_id, _, node_account_id, _, _ = mock_account_ids
+
+    key = PrivateKey.generate().public_key()
+    expiry = Timestamp(seconds=9_999_999_999, nanos=0)
+
+    tx = AccountUpdateTransaction()
+    tx.set_account_id(AccountId(0, 0, 1))
+    tx.set_key(key)
+    tx.set_expiration_time(expiry)
+    tx.set_staked_account_id(AccountId(0, 0, 9))
+    tx.transaction_id = TransactionId.generate(operator_id)
+    tx.node_account_id = node_account_id
+    tx.freeze()
+
+    reconstructed = Transaction.from_bytes(tx.to_bytes())
+
+    assert isinstance(reconstructed, AccountUpdateTransaction)
+    assert reconstructed.key.to_bytes_raw() == key.to_bytes_raw()
+    assert reconstructed.expiration_time.seconds == expiry.seconds
+    assert reconstructed.staked_account_id == AccountId(0, 0, 9)
+    assert reconstructed.staked_node_id is None

tests/unit/contract_create_transaction_test.py

@@ -449,3 +449,54 @@ def test_from_bytes(mock_account_ids):
     assert reconstructed.gas == 100_000
     assert reconstructed.bytecode == b"\x60\x80\x60\x40"
     assert reconstructed.contract_memo == "hello"
+
+
+def test_from_bytes_with_optional_fields(mock_account_ids):
+    """Covers adminKey, proxyAccountID, auto_renew_account_id, fileID, staked_account_id, staked_node_id."""
+    from hiero_sdk_python.transaction.transaction import Transaction
+    from hiero_sdk_python.transaction.transaction_id import TransactionId
+
+    operator_id, _, node_account_id, _, _ = mock_account_ids
+
+    admin_key = PrivateKey.generate().public_key()
+
+    tx = ContractCreateTransaction()
+    tx.set_admin_key(admin_key)
+    tx.set_bytecode_file_id(FileId(0, 0, 42))
+    tx.set_gas(1000)
+    tx.set_auto_renew_account_id(AccountId(0, 0, 5))
+    tx.set_staked_account_id(AccountId(0, 0, 6))
+    tx.transaction_id = TransactionId.generate(operator_id)
+    tx.node_account_id = node_account_id
+    tx.freeze()
+
+    reconstructed = Transaction.from_bytes(tx.to_bytes())
+
+    assert isinstance(reconstructed, ContractCreateTransaction)
+    assert reconstructed.admin_key is not None
+    assert reconstructed.bytecode_file_id == FileId(0, 0, 42)
+    assert reconstructed.auto_renew_account_id == AccountId(0, 0, 5)
+    assert reconstructed.staked_account_id == AccountId(0, 0, 6)
+    assert reconstructed.staked_node_id is None
+
+
+def test_from_bytes_with_staked_node_id(mock_account_ids):
+    """Covers staked_node_id branch in _from_protobuf."""
+    from hiero_sdk_python.transaction.transaction import Transaction
+    from hiero_sdk_python.transaction.transaction_id import TransactionId
+
+    operator_id, _, node_account_id, _, _ = mock_account_ids
+
+    tx = ContractCreateTransaction()
+    tx.set_bytecode(b"\x00")
+    tx.set_gas(1000)
+    tx.set_staked_node_id(7)
+    tx.transaction_id = TransactionId.generate(operator_id)
+    tx.node_account_id = node_account_id
+    tx.freeze()
+
+    reconstructed = Transaction.from_bytes(tx.to_bytes())
+
+    assert isinstance(reconstructed, ContractCreateTransaction)
+    assert reconstructed.staked_node_id == 7
+    assert reconstructed.staked_account_id is None

tests/unit/contract_delete_transaction_test.py

@@ -453,3 +453,25 @@ def test_from_bytes_with_permanent_removal(mock_account_ids):
     assert reconstructed.permanent_removal is True
     assert reconstructed.transfer_account_id is None
     assert reconstructed.transfer_contract_id is None
+
+
+def test_from_bytes_with_transfer_contract_id(mock_account_ids):
+    """Covers transferContractID branch in _from_protobuf."""
+    from hiero_sdk_python.transaction.transaction import Transaction
+    from hiero_sdk_python.transaction.transaction_id import TransactionId
+
+    operator_id, _, node_account_id, _, _ = mock_account_ids
+
+    tx = ContractDeleteTransaction()
+    tx.set_contract_id(ContractId(0, 0, 10))
+    tx.set_transfer_contract_id(ContractId(0, 0, 20))
+    tx.transaction_id = TransactionId.generate(operator_id)
+    tx.node_account_id = node_account_id
+    tx.freeze()
+
+    reconstructed = Transaction.from_bytes(tx.to_bytes())
+
+    assert isinstance(reconstructed, ContractDeleteTransaction)
+    assert reconstructed.contract_id == ContractId(0, 0, 10)
+    assert reconstructed.transfer_contract_id == ContractId(0, 0, 20)
+    assert reconstructed.transfer_account_id is None

tests/unit/contract_update_transaction_test.py

@@ -405,3 +405,61 @@ def test_from_bytes(mock_account_ids, contract_id):
     assert reconstructed.contract_id == contract_id
     assert reconstructed.contract_memo == "updated memo"
     assert reconstructed.auto_renew_period.seconds == 7_776_000
+
+
+def test_from_bytes_with_optional_fields(mock_account_ids, contract_id):
+    """Covers expiration_time, adminKey, max_auto_token_assoc, auto_renew_account, decline_reward, staked."""
+    from hiero_sdk_python.timestamp import Timestamp
+    from hiero_sdk_python.transaction.transaction import Transaction
+    from hiero_sdk_python.transaction.transaction_id import TransactionId
+
+    operator_id, _, node_account_id, _, _ = mock_account_ids
+
+    admin_key = PrivateKey.generate().public_key()
+    expiry = Timestamp(seconds=9_999_999_999, nanos=0)
+
+    tx = ContractUpdateTransaction()
+    tx.set_contract_id(contract_id)
+    tx.set_expiration_time(expiry)
+    tx.set_admin_key(admin_key)
+    tx.set_max_automatic_token_associations(5)
+    tx.set_auto_renew_account_id(AccountId(0, 0, 8))
+    tx.set_decline_reward(True)
+    tx.set_staked_account_id(AccountId(0, 0, 9))
+    tx.transaction_id = TransactionId.generate(operator_id)
+    tx.node_account_id = node_account_id
+    tx.freeze()
+
+    reconstructed = Transaction.from_bytes(tx.to_bytes())
+
+    assert isinstance(reconstructed, ContractUpdateTransaction)
+    assert reconstructed.expiration_time.seconds == expiry.seconds
+    assert reconstructed.admin_key is not None
+    assert reconstructed.max_automatic_token_associations == 5
+    assert reconstructed.auto_renew_account_id == AccountId(0, 0, 8)
+    assert reconstructed.decline_reward is True
+    assert reconstructed.staked_account_id == AccountId(0, 0, 9)
+
+
+def test_from_bytes_with_staked_node_id_and_old_memo(mock_account_ids, contract_id):
+    """Covers staked_node_id and old-format memo field in _from_protobuf."""
+    from hiero_sdk_python.hapi.services import contract_update_pb2, transaction_pb2
+
+    operator_id, _, node_account_id, _, _ = mock_account_ids
+
+    body = contract_update_pb2.ContractUpdateTransactionBody(
+        contractID=contract_id._to_proto(),
+        staked_node_id=4,
+        memo="old memo style",
+    )
+    tx_body = transaction_pb2.TransactionBody()
+    tx_body.contractUpdateInstance.CopyFrom(body)
+
+    from hiero_sdk_python.contract.contract_update_transaction import ContractUpdateTransaction
+
+    result = ContractUpdateTransaction._from_protobuf(tx_body, b"", None)
+
+    assert isinstance(result, ContractUpdateTransaction)
+    assert result.staked_node_id == 4
+    assert result.contract_memo == "old memo style"
+    assert result.staked_account_id is None

tests/unit/custom_fee_test.py

@@ -293,3 +293,38 @@ def test_set_amount_in_tinybars_deprecation():
     # Verify the method still works correctly
     assert fee.amount == 100
     assert fee.denominating_token_id is None
+
+
+def test_custom_fixed_fee_from_proto_raises_without_fixed_fee():
+    """_from_proto raises ValueError when proto has no fixed_fee field."""
+    from hiero_sdk_python.hapi.services.custom_fees_pb2 import CustomFee as CustomFeeProto
+
+    proto = CustomFeeProto()
+    with pytest.raises(ValueError, match="fixed_fee is required"):
+        CustomFixedFee._from_proto(proto)
+
+
+def test_custom_fixed_fee_from_topic_fee_proto():
+    """_from_topic_fee_proto deserializes a FixedCustomFee proto correctly."""
+
+    fee = CustomFixedFee(
+        amount=250,
+        denominating_token_id=TokenId(0, 0, 55),
+        fee_collector_account_id=AccountId(0, 0, 77),
+    )
+    proto = fee._to_topic_fee_proto()
+    result = CustomFixedFee._from_topic_fee_proto(proto)
+
+    assert isinstance(result, CustomFixedFee)
+    assert result.amount == 250
+    assert result.denominating_token_id == TokenId(0, 0, 55)
+    assert result.fee_collector_account_id == AccountId(0, 0, 77)
+
+
+def test_custom_fixed_fee_from_topic_fee_proto_raises_without_fixed_fee():
+    """_from_topic_fee_proto raises ValueError when proto has no fixed_fee."""
+    from hiero_sdk_python.hapi.services.custom_fees_pb2 import FixedCustomFee
+
+    proto = FixedCustomFee()
+    with pytest.raises(ValueError, match="fixed_fee is required"):
+        CustomFixedFee._from_topic_fee_proto(proto)

tests/unit/node_create_transaction_test.py

@@ -362,3 +362,27 @@ def test_from_bytes(mock_account_ids):
     assert reconstructed.service_endpoints[0].get_domain_name() == "service.example.com"
     assert reconstructed.gossip_ca_certificate == b"test-ca-cert"
     assert reconstructed.grpc_certificate_hash == b"test-cert-hash"
+
+
+def test_from_bytes_with_admin_key(mock_account_ids):
+    """Covers admin_key branch in _from_protobuf for NodeCreateTransaction."""
+    from hiero_sdk_python.crypto.private_key import PrivateKey
+    from hiero_sdk_python.transaction.transaction import Transaction
+    from hiero_sdk_python.transaction.transaction_id import TransactionId
+
+    operator_id, _, node_account_id, _, _ = mock_account_ids
+
+    admin_key = PrivateKey.generate_ed25519().public_key()
+
+    tx = NodeCreateTransaction()
+    tx.set_account_id(AccountId(0, 0, 99))
+    tx.set_admin_key(admin_key)
+    tx.transaction_id = TransactionId.generate(operator_id)
+    tx.node_account_id = node_account_id
+    tx.freeze()
+
+    reconstructed = Transaction.from_bytes(tx.to_bytes())
+
+    assert isinstance(reconstructed, NodeCreateTransaction)
+    assert reconstructed.admin_key is not None
+    assert reconstructed.admin_key.to_bytes_raw() == admin_key.to_bytes_raw()

tests/unit/node_update_transaction_test.py

@@ -385,3 +385,27 @@ def test_from_bytes(mock_account_ids):
     assert reconstructed.service_endpoints[0].get_domain_name() == "service.example.com"
     assert reconstructed.gossip_ca_certificate == b"test-ca-cert"
     assert reconstructed.grpc_certificate_hash == b"test-cert-hash"
+
+
+def test_from_bytes_with_admin_key(mock_account_ids):
+    """Covers admin_key branch in _from_protobuf for NodeUpdateTransaction."""
+    from hiero_sdk_python.crypto.private_key import PrivateKey
+    from hiero_sdk_python.transaction.transaction import Transaction
+    from hiero_sdk_python.transaction.transaction_id import TransactionId
+
+    operator_id, _, node_account_id, _, _ = mock_account_ids
+
+    admin_key = PrivateKey.generate_ed25519().public_key()
+
+    tx = NodeUpdateTransaction()
+    tx.set_node_id(2)
+    tx.set_admin_key(admin_key)
+    tx.transaction_id = TransactionId.generate(operator_id)
+    tx.node_account_id = node_account_id
+    tx.freeze()
+
+    reconstructed = Transaction.from_bytes(tx.to_bytes())
+
+    assert isinstance(reconstructed, NodeUpdateTransaction)
+    assert reconstructed.admin_key is not None
+    assert reconstructed.admin_key.to_bytes_raw() == admin_key.to_bytes_raw()

tests/unit/schedule_create_transaction_test.py

@@ -294,3 +294,30 @@ def test_from_bytes(mock_account_ids):
     assert reconstructed.payer_account_id == account_id_sender
     assert reconstructed.schedulable_body == schedulable_body
     assert reconstructed.schedulable_body.HasField("tokenGrantKyc")
+
+
+def test_from_bytes_with_admin_key_and_expiration(mock_account_ids):
+    """Covers admin_key and expiration_time branches in _from_protobuf."""
+    account_id_sender, _, node_account_id, token_id_1, _ = mock_account_ids
+
+    admin_key = PrivateKey.generate_ed25519().public_key()
+    expiry = Timestamp(seconds=9_999_999_999, nanos=0)
+
+    inner_tx = TokenGrantKycTransaction()
+    inner_tx.set_token_id(token_id_1)
+    inner_tx.set_account_id(account_id_sender)
+    schedulable_body = inner_tx.build_scheduled_body()
+
+    tx = ScheduleCreateTransaction()
+    tx.set_admin_key(admin_key)
+    tx.set_expiration_time(expiry)
+    tx._set_schedulable_body(schedulable_body)
+    tx.transaction_id = TransactionId.generate(account_id_sender)
+    tx.node_account_id = node_account_id
+    tx.freeze()
+
+    reconstructed = Transaction.from_bytes(tx.to_bytes())
+
+    assert isinstance(reconstructed, ScheduleCreateTransaction)
+    assert reconstructed.admin_key is not None
+    assert reconstructed.expiration_time.seconds == expiry.seconds

tests/unit/token_airdrop_transaction_test.py

@@ -447,3 +447,62 @@ def test_from_bytes_nft(mock_account_ids):
     assert nft_transfers[0].receiver_id == receiver
     assert nft_transfers[0].serial_number == 7
     assert not nft_transfers[0].is_approved
+
+
+def test_from_protobuf_skips_transfer_without_token():
+    """Covers continue branch when token field is missing from a TokenTransferList."""
+    from hiero_sdk_python.hapi.services import transaction_pb2
+    from hiero_sdk_python.hapi.services.basic_types_pb2 import TokenTransferList
+    from hiero_sdk_python.hapi.services.token_airdrop_pb2 import TokenAirdropTransactionBody
+
+    body = TokenAirdropTransactionBody()
+    body.token_transfers.append(TokenTransferList())
+    tx_body = transaction_pb2.TransactionBody()
+    tx_body.tokenAirdrop.CopyFrom(body)
+
+    result = TokenAirdropTransaction._from_protobuf(tx_body, b"", None)
+
+    assert isinstance(result, TokenAirdropTransaction)
+    assert len(result.token_transfers) == 0
+
+
+def test_from_protobuf_skips_fungible_transfer_without_account_id(mock_account_ids):
+    """Covers continue branch when accountID is missing from a fungible transfer."""
+    from hiero_sdk_python.hapi.services import transaction_pb2
+    from hiero_sdk_python.hapi.services.basic_types_pb2 import AccountAmount, TokenTransferList
+    from hiero_sdk_python.hapi.services.token_airdrop_pb2 import TokenAirdropTransactionBody
+
+    _, _, _, token_id_1, _ = mock_account_ids
+
+    body = TokenAirdropTransactionBody()
+    transfer_list = TokenTransferList(token=token_id_1._to_proto())
+    transfer_list.transfers.append(AccountAmount(amount=100))
+    body.token_transfers.append(transfer_list)
+    tx_body = transaction_pb2.TransactionBody()
+    tx_body.tokenAirdrop.CopyFrom(body)
+
+    result = TokenAirdropTransaction._from_protobuf(tx_body, b"", None)
+
+    assert isinstance(result, TokenAirdropTransaction)
+    assert len(result.token_transfers[token_id_1]) == 0
+
+
+def test_from_protobuf_skips_nft_transfer_without_sender_or_receiver(mock_account_ids):
+    """Covers continue branch when senderAccountID or receiverAccountID is missing from NFT transfer."""
+    from hiero_sdk_python.hapi.services import transaction_pb2
+    from hiero_sdk_python.hapi.services.basic_types_pb2 import NftTransfer, TokenTransferList
+    from hiero_sdk_python.hapi.services.token_airdrop_pb2 import TokenAirdropTransactionBody
+
+    _, _, _, token_id_1, _ = mock_account_ids
+
+    body = TokenAirdropTransactionBody()
+    transfer_list = TokenTransferList(token=token_id_1._to_proto())
+    transfer_list.nftTransfers.append(NftTransfer(serialNumber=1))
+    body.token_transfers.append(transfer_list)
+    tx_body = transaction_pb2.TransactionBody()
+    tx_body.tokenAirdrop.CopyFrom(body)
+
+    result = TokenAirdropTransaction._from_protobuf(tx_body, b"", None)
+
+    assert isinstance(result, TokenAirdropTransaction)
+    assert len(result.nft_transfers[token_id_1]) == 0