feat: Add UnfreezeToken To TCK (#2529)

Signed-off-by: aceppaluni <aceppaluni@gmail.com>

Author: aceppaluni

src/hiero_sdk_python/tokens/token_unfreeze_transaction.py

@@ -76,19 +76,16 @@ def _build_proto_body(self) -> token_unfreeze_account_pb2.TokenUnfreezeAccountTr
 
         Returns:
             TokenUnfreezeAccountTransactionBody: The protobuf body for this transaction.
-
-        Raises:
-            ValueError: If account ID or token ID is not set.
         """
-        if not self.token_id:
-            raise ValueError("Missing required TokenID.")
+        body = token_unfreeze_account_pb2.TokenUnfreezeAccountTransactionBody()
+
+        if self.token_id is not None:
+            body.token.CopyFrom(self.token_id._to_proto())
 
-        if not self.account_id:
-            raise ValueError("Missing required AccountID.")
+        if self.account_id is not None:
+            body.account.CopyFrom(self.account_id._to_proto())
 
-        return token_unfreeze_account_pb2.TokenUnfreezeAccountTransactionBody(
-            account=self.account_id._to_proto(), token=self.token_id._to_proto()
-        )
+        return body
 
     def build_transaction_body(self) -> transaction_pb2.TransactionBody:
         """

tck/handlers/token.py

@@ -35,6 +35,7 @@
 from hiero_sdk_python.tokens.token_reject_transaction import TokenRejectTransaction
 from hiero_sdk_python.tokens.token_revoke_kyc_transaction import TokenRevokeKycTransaction
 from hiero_sdk_python.tokens.token_type import TokenType
+from hiero_sdk_python.tokens.token_unfreeze_transaction import TokenUnfreezeTransaction
 from hiero_sdk_python.tokens.token_update_transaction import TokenUpdateTransaction
 from hiero_sdk_python.tokens.token_wipe_transaction import TokenWipeTransaction
 from hiero_sdk_python.transaction.transaction_receipt import TransactionReceipt
@@ -55,6 +56,7 @@
     PauseTokenParams,
     RejectTokenParams,
     RevokeTokenKycParams,
+    UnfreezeTokenParams,
     UpdateTokenParams,
     WipeTokenParams,
 )
@@ -74,6 +76,7 @@
     PauseTokenResponse,
     RejectTokenResponse,
     RevokeTokenKycResponse,
+    UnfreezeTokenResponse,
     UpdateTokenResponse,
     WipeTokenResponse,
 )
@@ -419,6 +422,37 @@ def dissociate_token(params: DissociateTokenParams) -> DissociateTokenResponse:
     return DissociateTokenResponse(status=ResponseCode(receipt.status).name)
 
 
+def _build_unfreeze_token_transaction(
+    params: UnfreezeTokenParams,
+) -> TokenUnfreezeTransaction:
+    """Build a TokenUnfreezeTransaction from TCK params."""
+    transaction = TokenUnfreezeTransaction().set_grpc_deadline(DEFAULT_GRPC_TIMEOUT)
+
+    if params.tokenId is not None:
+        transaction.set_token_id(TokenId.from_string(params.tokenId))
+
+    if params.accountId is not None:
+        transaction.set_account_id(AccountId.from_string(params.accountId))
+
+    return transaction
+
+
+@rpc_method("unfreezeToken")
+def unfreeze_token(params: UnfreezeTokenParams) -> UnfreezeTokenResponse:
+    """Unfreeze a token for an account using TCK unfreezeToken parameters."""
+    client = get_client(params.sessionId)
+
+    transaction = _build_unfreeze_token_transaction(params)
+
+    if params.commonTransactionParams is not None:
+        params.commonTransactionParams.apply_common_params(transaction, client)
+
+    response = transaction.execute(client, wait_for_receipt=False)
+    receipt: TransactionReceipt = response.get_receipt(client, validate_status=True)
+
+    return UnfreezeTokenResponse(status=ResponseCode(receipt.status).name)
+
+
 @rpc_method("freezeToken")
 def freeze_token(params: FreezeTokenParams) -> FreezeTokenResponse:
     """Freeze a token for an account using TCK freezeToken parameters."""

tck/param/token.py

@@ -166,6 +166,23 @@ def parse_json_params(cls, params: dict) -> FreezeTokenParams:
         )
 
 
+@dataclass
+class UnfreezeTokenParams(BaseTransactionParams):
+    """Request parameters for the unfreezeToken endpoint."""
+
+    tokenId: str | None = None
+    accountId: str | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> UnfreezeTokenParams:
+        return cls(
+            tokenId=params.get("tokenId"),
+            accountId=params.get("accountId"),
+            sessionId=parse_session_id(params),
+            commonTransactionParams=parse_common_transaction_params(params),
+        )
+
+
 @dataclass
 class DissociateTokenParams(BaseTransactionParams):
     """Request parameters for the dissociateToken endpoint."""

tck/response/token.py

@@ -44,6 +44,11 @@ class FreezeTokenResponse(StatusOnlyResponse):
     """Response payload for freezeToken."""
 
 
+@dataclass
+class UnfreezeTokenResponse(StatusOnlyResponse):
+    """Response payload for unfreezeToken."""
+
+
 @dataclass
 class GrantTokenKycResponse(StatusOnlyResponse):
     """Response payload for grantTokenKyc."""

tests/unit/token_unfreeze_transaction_test.py

@@ -47,25 +47,29 @@ def test_build_transaction_body(mock_account_ids):
 
 
 def test_missing_token_id(mock_account_ids):
-    """Test that building a transaction without setting
-    TokenID raises a ValueError.
-    """
-    account_id, freeze_id, node_account_id, token_id, _ = mock_account_ids
+    """Test that building the protobuf body without TokenID ignores the missing ID."""
+    _, freeze_id, _, _, _ = mock_account_ids
 
     unfreeze_tx = TokenUnfreezeTransaction()
     unfreeze_tx.set_account_id(freeze_id)
-    with pytest.raises(ValueError, match="Missing required TokenID."):
-        unfreeze_tx.build_transaction_body()
+
+    body = unfreeze_tx._build_proto_body()
+
+    assert not body.HasField("token")
+    assert body.account == freeze_id._to_proto()
 
 
 def test_missing_account_id(mock_account_ids):
-    """Test that building a transaction without setting AccountID raises a ValueError."""
-    account_id, freeze_id, node_account_id, token_id, _ = mock_account_ids
+    """Test that building the protobuf body without AccountID ignores the missing ID."""
+    _, _, _, token_id, _ = mock_account_ids
 
     unfreeze_tx = TokenUnfreezeTransaction()
     unfreeze_tx.set_token_id(token_id)
-    with pytest.raises(ValueError, match="Missing required AccountID."):
-        unfreeze_tx.build_transaction_body()
+
+    body = unfreeze_tx._build_proto_body()
+
+    assert not body.HasField("account")
+    assert body.token == token_id._to_proto()
 
 
 def test_sign_transaction(mock_account_ids, mock_client):