Merge branch 'feat/tck-append-file' of fork into feat/tck-append-file

Author: tannaya7

.github/workflows/publish.yml

@@ -115,7 +115,7 @@ jobs:
           attestations: true
 
       - name: Upload signed assets to GitHub Release
-        uses: softprops/action-gh-release@3d0d9888cb7fd7b750713d6e236d1fcb99157228 # v3.0.2
+        uses: softprops/action-gh-release@efb35369e0ad2afab669f228072c1b0d510eae64 # v3.0.3
         with:
           body: |
             ## Important notes

src/hiero_sdk_python/tokens/token_unpause_transaction.py

@@ -82,7 +82,7 @@ def _from_proto(cls, proto: TokenUnpauseTransactionBody) -> TokenUnpauseTransact
         Returns:
             TokenUnpauseTransaction: A new instance of TokenUnpauseTransaction
         """
-        token_id = TokenId._from_proto(proto.token) if proto.token else None
+        token_id = TokenId._from_proto(proto.token) if proto.HasField("token") else None
         return cls(token_id=token_id)
 
     def _build_proto_body(self) -> TokenUnpauseTransactionBody:
@@ -91,14 +91,8 @@ def _build_proto_body(self) -> TokenUnpauseTransactionBody:
 
         Returns:
             TokenUnpauseTransactionBody: The protobuf body for this transaction.
-
-        Raises:
-            ValueError: If account ID or token ID is not set.
         """
-        if self.token_id is None:
-            raise ValueError("Missing token ID")
-
-        return TokenUnpauseTransactionBody(token=self.token_id._to_proto())
+        return TokenUnpauseTransactionBody(token=self.token_id._to_proto() if self.token_id is not None else None)
 
     def build_transaction_body(self) -> TransactionBody:
         """

tck/handlers/token.py

@@ -39,6 +39,7 @@
 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_unpause_transaction import TokenUnpauseTransaction
 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
@@ -62,6 +63,7 @@
     RejectTokenParams,
     RevokeTokenKycParams,
     UnfreezeTokenParams,
+    UnpauseTokenParams,
     UpdateTokenParams,
     WipeTokenParams,
 )
@@ -84,6 +86,7 @@
     RejectTokenResponse,
     RevokeTokenKycResponse,
     UnfreezeTokenResponse,
+    UnpauseTokenResponse,
     UpdateTokenResponse,
     WipeTokenResponse,
 )
@@ -407,6 +410,16 @@ def _build_pause_token_transaction(params: PauseTokenParams) -> TokenPauseTransa
     return transaction
 
 
+def _build_unpause_token_transaction(params: UnpauseTokenParams) -> TokenUnpauseTransaction:
+    """Build a TokenUnpauseTransaction from TCK params."""
+    transaction = TokenUnpauseTransaction().set_grpc_deadline(DEFAULT_GRPC_TIMEOUT)
+
+    if params.tokenId is not None:
+        transaction.set_token_id(TokenId.from_string(params.tokenId))
+
+    return transaction
+
+
 def _build_grant_token_kyc_transaction(params: GrantTokenKycParams) -> TokenGrantKycTransaction:
     """Build a TokenGrantKycTransaction from TCK params."""
     transaction = TokenGrantKycTransaction().set_grpc_deadline(DEFAULT_GRPC_TIMEOUT)
@@ -540,6 +553,22 @@ def pause_token(params: PauseTokenParams) -> PauseTokenResponse:
     return PauseTokenResponse(status=ResponseCode(receipt.status).name)
 
 
+@rpc_method("unpauseToken")
+def unpause_token(params: UnpauseTokenParams) -> UnpauseTokenResponse:
+    """Unpause a token using TCK unpauseToken parameters."""
+    client = get_client(params.sessionId)
+
+    transaction = _build_unpause_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 UnpauseTokenResponse(status=ResponseCode(receipt.status).name)
+
+
 @rpc_method("grantTokenKyc")
 def grant_token_kyc(params: GrantTokenKycParams) -> GrantTokenKycResponse:
     """Grant KYC to an account for a token using TCK grantTokenKyc parameters."""

tck/param/token.py

@@ -259,6 +259,22 @@ def parse_json_params(cls, params: dict) -> PauseTokenParams:
         )
 
 
+@dataclass
+class UnpauseTokenParams(BaseTransactionParams):
+    """Request parameters for the unpauseToken endpoint."""
+
+    tokenId: str | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> UnpauseTokenParams:
+        """Parse JSON-RPC params into an UnpauseTokenParams instance."""
+        return cls(
+            tokenId=params.get("tokenId"),
+            sessionId=parse_session_id(params),
+            commonTransactionParams=parse_common_transaction_params(params),
+        )
+
+
 @dataclass
 class AirdropTokenParams(BaseTransactionParams):
     """Request parameters for the airdropToken endpoint."""

tck/response/token.py

@@ -69,6 +69,11 @@ class PauseTokenResponse(StatusOnlyResponse):
     """Response payload for pauseToken."""
 
 
+@dataclass
+class UnpauseTokenResponse(StatusOnlyResponse):
+    """Response payload for unpauseToken."""
+
+
 @dataclass
 class AirdropTokenResponse(StatusOnlyResponse):
     """Response payload for airdropToken."""

tests/integration/token_unpause_transaction_e2e_test.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import pytest
-from pytest import fixture
 
 from hiero_sdk_python.crypto.private_key import PrivateKey
+from hiero_sdk_python.exceptions import PrecheckError
 from hiero_sdk_python.query.token_info_query import TokenInfoQuery
 from hiero_sdk_python.response_code import ResponseCode
 from hiero_sdk_python.tokens.token_id import TokenId
@@ -15,17 +15,17 @@
 pause_key = PrivateKey.generate()
 
 
-@fixture
+@pytest.fixture
 def pausable_token(env):
-    """ "Fixture to create a token that supports pausing."""
+    """Fixture to create a token that supports pausing."""
     return create_fungible_token(env, opts=[lambda tx: tx.set_pause_key(pause_key)])
 
 
 def pause_token(env, token_id: TokenId):
     """Helper function to pause the token with the given token_id."""
-    token_pasue_tx = TokenPauseTransaction().set_token_id(token_id).freeze_with(env.client).sign(pause_key)
+    token_pause_tx = TokenPauseTransaction().set_token_id(token_id).freeze_with(env.client).sign(pause_key)
 
-    return token_pasue_tx.execute(env.client)
+    return token_pause_tx.execute(env.client)
 
 
 def get_pause_status(env, token_id: TokenId):
@@ -34,6 +34,7 @@ def get_pause_status(env, token_id: TokenId):
     return token_info.pause_status.name
 
 
+@pytest.mark.integration
 def test_unpause_token(env, pausable_token):
     """Test successful unpause of a paused token."""
     pause_receipt = pause_token(env, pausable_token)
@@ -48,6 +49,7 @@ def test_unpause_token(env, pausable_token):
     assert get_pause_status(env, pausable_token) == "UNPAUSED"
 
 
+@pytest.mark.integration
 def test_unpause_token_without_pause_key_signature(env, pausable_token):
     """Test unpause transaction without pause key signature."""
     pause_receipt = pause_token(env, pausable_token)
@@ -61,7 +63,8 @@ def test_unpause_token_without_pause_key_signature(env, pausable_token):
     assert unpause_receipt.status == ResponseCode.INVALID_SIGNATURE
 
 
-def test_unpause_token_with_invalid_pasue_key(env, pausable_token):
+@pytest.mark.integration
+def test_unpause_token_with_invalid_pause_key(env, pausable_token):
     """Test unpause transaction with invalid pause key."""
     pause_receipt = pause_token(env, pausable_token)
 
@@ -76,16 +79,19 @@ def test_unpause_token_with_invalid_pasue_key(env, pausable_token):
     assert unpause_receipt.status == ResponseCode.INVALID_SIGNATURE
 
 
+@pytest.mark.integration
 def test_unpause_token_when_token_id_not_set(env):
     """Test unpause transaction when token_id is not provided."""
     unpause_tx = TokenUnpauseTransaction()
-    with pytest.raises(ValueError, match="Missing token ID"):
-        unpause_tx.freeze_with(env.client)
+    with pytest.raises(PrecheckError, match="failed precheck with status: INVALID_TOKEN_ID") as exc_info:
+        unpause_tx.execute(env.client)
+    assert exc_info.value.status == ResponseCode.INVALID_TOKEN_ID
 
 
+@pytest.mark.integration
 def test_unpause_token_with_invalid_token_id(env):
     """Test unpause transaction using an invalid token ID."""
-    token_id = TokenId(0, 0, 999)
+    token_id = TokenId(0, 0, 0)
 
     unpause_tx = TokenUnpauseTransaction().set_token_id(token_id).freeze_with(env.client).sign(pause_key)
 

tests/unit/token_unpause_transaction_test.py

@@ -62,9 +62,10 @@ def test_build_transaction_body_when_token_id_not_set(mock_account_ids):
 
     unpause_tx = TokenUnpauseTransaction()
     unpause_tx.set_node_account_ids([node_account_id])
+    unpause_tx.operator_account_id = account_id
 
-    with pytest.raises(ValueError, match="Missing token ID"):
-        unpause_tx.build_transaction_body()
+    transaction_body = unpause_tx.build_transaction_body()
+    assert not transaction_body.token_unpause.HasField("token"), "token field must be unset when token_id is None"
 
 
 def test_set_method(mock_account_ids):
@@ -169,6 +170,14 @@ def test_from_proto(mock_account_ids):
     assert unpause_tx.token_id.num == token_id.num
 
 
+def test_from_proto_without_token():
+    """Test creating a TokenUnpauseTransaction from protobuf representation without token."""
+    proto = TokenUnpauseTransactionBody()
+    unpause_tx = TokenUnpauseTransaction._from_proto(proto)
+
+    assert unpause_tx.token_id is None, "token_id must remain None when token is absent"
+
+
 def test_upause_transaction_can_execute(mock_account_ids):
     """Test that a token upause transaction can be executed successfully."""
     _, _, _, token_id, _ = mock_account_ids