feat: set_max_transaction to client

Signed-off-by: tech0priyanshu <priyanshuyadv101106@gmail.com>

Author: tech0priyanshu

src/hiero_sdk_python/client/client.py

@@ -59,6 +59,7 @@ def __init__(self, network: Network = None) -> None:
 
         self.max_attempts: int = 10
         self.default_max_query_payment: Hbar = DEFAULT_MAX_QUERY_PAYMENT
+        self.default_max_transaction_fee: Hbar = None
 
         self._min_backoff: float = DEFAULT_MIN_BACKOFF
         self._max_backoff: float = DEFAULT_MAX_BACKOFF
@@ -288,6 +289,27 @@ def set_default_max_query_payment(self, max_query_payment: int | float | Decimal
         self.default_max_query_payment = value
         return self
 
+    def set_max_transaction_fee(
+        self,
+        max_transaction_fee: int | float | Decimal | Hbar,
+    ) -> Client:
+
+        if isinstance(max_transaction_fee, bool) or not isinstance(
+            max_transaction_fee,
+            (int, float, Decimal, Hbar),
+        ):
+            raise TypeError(
+                f"max_transaction_fee must be int, float, Decimal, or Hbar, got {type(max_transaction_fee).__name__}"
+            )
+
+        value = max_transaction_fee if isinstance(max_transaction_fee, Hbar) else Hbar(max_transaction_fee)
+
+        if value < Hbar(0):
+            raise ValueError("max_transaction_fee must be non-negative")
+
+        self.default_max_transaction_fee = value
+        return self
+
     def set_max_attempts(self, max_attempts: int) -> Client:
         """
         Set the maximum number of execution attempts for all transactions and queries

src/hiero_sdk_python/transaction/transaction.py

@@ -1,16 +1,25 @@
 from __future__ import annotations
 
 import hashlib
+from decimal import Decimal
 from typing import TYPE_CHECKING, Literal, overload
 
 from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.client.client import Client
 from hiero_sdk_python.crypto.key import Key
 from hiero_sdk_python.exceptions import PrecheckError
 from hiero_sdk_python.executable import _Executable, _ExecutionState
-from hiero_sdk_python.hapi.services import basic_types_pb2, transaction_contents_pb2, transaction_pb2
-from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import SchedulableTransactionBody
-from hiero_sdk_python.hapi.services.transaction_response_pb2 import TransactionResponse as TransactionResponseProto
+from hiero_sdk_python.hapi.services import (
+    basic_types_pb2,
+    transaction_contents_pb2,
+    transaction_pb2,
+)
+from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import (
+    SchedulableTransactionBody,
+)
+from hiero_sdk_python.hapi.services.transaction_response_pb2 import (
+    TransactionResponse as TransactionResponseProto,
+)
 from hiero_sdk_python.hbar import Hbar
 from hiero_sdk_python.query.fee_estimate_query import FeeEstimateQuery
 from hiero_sdk_python.response_code import ResponseCode
@@ -314,6 +323,16 @@ def freeze_with(self, client: Client):
 
         else:
             # Use all nodes from client network
+            # Resolve fee priority before building bodies:
+            # 1. Explicit transaction fee (self.transaction_fee)
+            # 2. Client default_max_transaction_fee
+            # 3. Transaction class default (_default_transaction_fee)
+            if self.transaction_fee is None:
+                if client is not None and getattr(client, "default_max_transaction_fee", None) is not None:
+                    self.transaction_fee = client.default_max_transaction_fee
+                else:
+                    self.transaction_fee = self._default_transaction_fee
+
             for node in client.network.nodes:
                 self.node_account_id = node._account_id
                 self._transaction_body_bytes[node._account_id] = self.build_transaction_body().SerializeToString()
@@ -746,6 +765,22 @@ def from_bytes(transaction_bytes: bytes):
             transaction_body, signed_transaction.bodyBytes, signed_transaction.sigMap
         )
 
+    def set_max_transaction_fee(self, max_transaction_fee):
+        # Accept int, float, Decimal, or Hbar (but not bool)
+
+        if isinstance(max_transaction_fee, bool) or not isinstance(max_transaction_fee, (int, float, Decimal, Hbar)):
+            raise TypeError(
+                f"max_transaction_fee must be int, float, Decimal, or Hbar, got {type(max_transaction_fee).__name__}"
+            )
+
+        value = max_transaction_fee if isinstance(max_transaction_fee, Hbar) else Hbar(max_transaction_fee)
+
+        if value < Hbar(0):
+            raise ValueError("max_transaction_fee must be non-negative")
+
+        self.transaction_fee = value
+        return self
+
     @staticmethod
     def _get_transaction_class(transaction_type: str):
         """

tests/unit/client_test.py

@@ -231,6 +231,49 @@ def test_set_default_max_query_payment_valid_param(valid_amount, expected):
     assert client.default_max_query_payment == expected
 
 
+def test_default_max_transaction_fee_is_none():
+    """Default `default_max_transaction_fee` should be None."""
+    client = Client.for_testnet()
+    assert client.default_max_transaction_fee is None
+
+
+@pytest.mark.parametrize(
+    "valid_amount,expected",
+    [
+        (1, Hbar(1)),
+        (0.1, Hbar(0.1)),
+        (Decimal("0.1"), Hbar(Decimal("0.1"))),
+        (Hbar(1), Hbar(1)),
+        (Hbar(0), Hbar(0)),
+    ],
+)
+def test_set_default_max_transaction_fee_valid_param(valid_amount, expected):
+    """Test set_max_transaction_fee converts inputs to Hbar and stores them."""
+    client = Client.for_testnet()
+
+    returned = client.set_max_transaction_fee(valid_amount)
+    assert client.default_max_transaction_fee == expected
+    assert returned is client
+
+
+@pytest.mark.parametrize("invalid_amount", ["1", True, False, None, object()])
+def test_set_default_max_transaction_fee_invalid_param(invalid_amount):
+    """Test set_max_transaction_fee rejects invalid types."""
+    client = Client.for_testnet()
+
+    with pytest.raises(TypeError):
+        client.set_max_transaction_fee(invalid_amount)
+
+
+@pytest.mark.parametrize("negative_amount", [-1, -0.1, Decimal("-0.1"), Hbar(-1)])
+def test_set_default_max_transaction_fee_negative_value(negative_amount):
+    """Test set_max_transaction_fee rejects negative values."""
+    client = Client.for_testnet()
+
+    with pytest.raises(ValueError):
+        client.set_max_transaction_fee(negative_amount)
+
+
 @pytest.mark.parametrize("negative_amount", [-1, -0.1, Decimal("-0.1"), Decimal("-1"), Hbar(-1)])
 def test_set_default_max_query_payment_negative_value(negative_amount):
     """Test set_default_max_query_payment for negative amount values."""

tests/unit/transaction_freeze_and_bytes_test.py

@@ -8,13 +8,16 @@
 
 from __future__ import annotations
 
+from decimal import Decimal
+
 import pytest
 
 from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.crypto.private_key import PrivateKey
 from hiero_sdk_python.hapi.services.transaction_response_pb2 import (
     TransactionResponse as TransactionResponseProto,
 )
+from hiero_sdk_python.hbar import Hbar
 from hiero_sdk_python.transaction.transaction_id import TransactionId
 from hiero_sdk_python.transaction.transfer_transaction import TransferTransaction
 
@@ -59,9 +62,44 @@ def test_freeze_with_valid_parameters():
     # Should return self for method chaining
     assert result is transaction
 
-    # Should have transaction body bytes set
-    assert len(transaction._transaction_body_bytes) > 0
-    assert node_id in transaction._transaction_body_bytes
+
+@pytest.mark.parametrize(
+    "valid_amount,expected",
+    [
+        (1, Hbar(1)),
+        (0.1, Hbar(0.1)),
+        (Decimal("0.1"), Hbar(Decimal("0.1"))),
+        (Hbar(1), Hbar(1)),
+        (Hbar(0), Hbar(0)),
+    ],
+)
+def test_set_max_transaction_fee_valid_param(valid_amount, expected):
+    """Transaction.set_max_transaction_fee should accept various numeric types and Hbar."""
+    tx = TransferTransaction()
+
+    returned = tx.set_max_transaction_fee(valid_amount)
+    assert tx.transaction_fee == expected
+    assert returned is tx
+
+
+@pytest.mark.parametrize("invalid_amount", ["1", True, False, None, object()])
+def test_set_max_transaction_fee_invalid_param(invalid_amount):
+    """Transaction.set_max_transaction_fee should reject invalid types."""
+    tx = TransferTransaction()
+
+    with pytest.raises(TypeError):
+        tx.set_max_transaction_fee(invalid_amount)
+
+
+@pytest.mark.parametrize("negative_amount", [-1, -0.1, Decimal("-0.1"), Hbar(-1)])
+def test_set_max_transaction_fee_negative_value(negative_amount):
+    """Transaction.set_max_transaction_fee should reject negative values."""
+    tx = TransferTransaction()
+
+    with pytest.raises(ValueError):
+        tx.set_max_transaction_fee(negative_amount)
+    # checking state un modified
+    assert len(tx._transaction_body_bytes) == 0
 
 
 def test_freeze_is_idempotent():
@@ -685,3 +723,41 @@ def test_map_response_raises_if_proto_request_is_not_transaction():
             node_id=mock_node_id,
             proto_request=invalid_proto_request,
         )
+
+
+def test_fee_resolution_transaction_precedence(mock_client):
+    """Transaction fee explicitly set should take precedence over client default."""
+    tx = TransferTransaction()
+    tx.set_max_transaction_fee(Hbar(10))
+
+    # client has different default
+    mock_client.set_max_transaction_fee(Hbar(5))
+
+    tx.freeze_with(mock_client)
+
+    assert tx.transaction_fee == Hbar(10)
+
+
+def test_fee_resolution_client_default_used_when_transaction_missing(mock_client):
+    """When transaction fee is not set, client.default_max_transaction_fee should be used."""
+    tx = TransferTransaction()
+    # leave tx.transaction_fee as None
+
+    mock_client.set_max_transaction_fee(Hbar(7))
+
+    tx.freeze_with(mock_client)
+
+    assert tx.transaction_fee == Hbar(7)
+
+
+def test_fee_resolution_falls_back_to_transaction_default(mock_client):
+    """When neither transaction nor client provide a fee, fallback to transaction default Hbar(1)."""
+    tx = TransferTransaction()
+    tx.set_transaction_id(TransactionId.generate(AccountId.from_string("0.0.1234")))
+    # Ensure client default is None
+    mock_client.default_max_transaction_fee = None
+
+    tx.freeze_with(mock_client)
+
+    assert tx.transaction_fee == 100000000  # Default fee for TransferTransaction
+    print(tx.__class__.__mro__)