feat: Added TokenUnpauseTransaction (#643)

Signed-off-by: Manish Dait <[email protected]>

Author: manishdait

CHANGELOG.md

@@ -13,8 +13,8 @@ This changelog is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.
 - Added comprehensive Google-style docstrings to the `Logger` class and all utility functions in `src/hiero_sdk_python/logger/logger.py` (#639).
 - add AccountRecordsQuery class
 - Transaction bytes serialization support: `Transaction.freeze()`, `Transaction.to_bytes()`, and `Transaction.from_bytes()` methods for offline signing and transaction storage
-
 - docs: Add Google-style docstrings to `ContractId` class and methods in `contract_id.py`.
+- Added TokenUnpauseTransaction class
 
 ### Changed
 - chore: validate that token airdrop transactions require an available token service on the channel (#632) 

docs/sdk_users/running_examples.md

@@ -37,6 +37,7 @@ You can choose either syntax or even mix both styles in your projects.
   - [Burning a Non-Fungible Token](#burning-a-non-fungible-token)
   - [Token Update NFTs](#token-update-nfts)
   - [Pausing a Token](#pausing-a-token)
+  - [Unpausing a Token](#unpausing-a-token)
   - [Token Grant KYC](#token-grant-kyc)
   - [Token Revoke KYC](#token-revoke-kyc)
   - [Updating a Token](#updating-a-token)
@@ -839,6 +840,29 @@ transaction.execute(client)
 
 ```
 
+### Unpausing a Token
+
+#### Pythonic Syntax:
+```
+transaction = TokenUnpauseTransaction(
+    token_id=token_id
+).freeze_with(client)
+
+transaction.sign(pause_key)
+transaction.execute(client)
+```
+
+#### Method Chaining:
+```
+transaction = (
+    TokenUnpauseTransaction()
+    .set_token_id(token_id)
+    .freeze_with(client)
+    .sign(pause_key)
+)
+transaction.execute(client)
+```
+
 ### Token Grant KYC
 
 #### Pythonic Syntax:

examples/token_unpause.py

@@ -0,0 +1,130 @@
+"""
+uv run examples/token_unpause.py
+python examples/token_unpause.py
+
+"""
+import os
+import sys
+from dotenv import load_dotenv
+
+from hiero_sdk_python import (
+    Client,
+    AccountId,
+    PrivateKey,
+    Network,
+    ResponseCode,
+    TokenId,
+    TokenType,
+    TokenCreateTransaction,
+    TokenUnpauseTransaction,
+    TokenPauseTransaction,
+    TokenInfoQuery
+)
+
+load_dotenv()
+
+def setup_client():
+    """Initialize and set up the client with operator account"""
+    print("Connecting to Hedera testnet...")
+
+    try:
+        network = Network(os.getenv('NETWORK'))
+        client = Client(network)
+        
+        operator_id = AccountId.from_string(os.getenv('OPERATOR_ID'))
+        operator_key = PrivateKey.from_string(os.getenv('OPERATOR_KEY'))
+        client.set_operator(operator_id, operator_key)
+    
+        return client, operator_id, operator_key
+    except (TypeError, ValueError):
+        print("❌ Error: Creating client, Please check your .env file")
+        sys.exit(1)
+
+def create_token(client: Client, operator_id: AccountId, pause_key: PrivateKey,):
+    """Create a fungible token"""
+    print("\nCreating a token...")
+
+    try:
+        token_tx = (
+            TokenCreateTransaction()
+            .set_token_name("Token A")
+            .set_token_symbol("TKA")
+            .set_initial_supply(1)
+            .set_treasury_account_id(operator_id)
+            .set_token_type(TokenType.FUNGIBLE_COMMON)
+            .set_pause_key(pause_key)         # Required for pausing tokens
+            .freeze_with(client)
+        )
+    
+        receipt = token_tx.sign(pause_key).execute(client)
+    
+        token_id = receipt.token_id
+        print(f"✅ Success! Created token: {token_id}")
+        check_pause_status(client, token_id)
+    
+        return token_id
+    except Exception as e:
+        print(f"❌ Error creating token: {e}")
+        sys.exit(1)
+
+def pause_token(client: Client, token_id: TokenId, pause_key: PrivateKey):
+    """Pause token"""
+    print("\nAttempting to pause the token...")
+
+    try:
+        pause_tx = (
+            TokenPauseTransaction()
+            .set_token_id(token_id)
+            .freeze_with(client)
+            .sign(pause_key)
+        )
+    
+        receipt = pause_tx.execute(client)
+
+        if receipt.status == ResponseCode.SUCCESS:
+            print(f"✅ Successfully paused token: {token_id}")
+            check_pause_status(client, token_id)
+        else:
+            print(f"❌ Transaction completed, but status is: {receipt.status.name}")
+            sys.exit(1)
+    except Exception as e:
+        print(f"❌ Error pausing token: {e}")
+        sys.exit(1)
+
+def check_pause_status(client, token_id: TokenId):
+    """Query and print the current paused/unpaused status of a token."""
+    info = TokenInfoQuery().set_token_id(token_id).execute(client)
+    print(f"Token status is now: {info.pause_status.name}")
+    
+
+def unpause_token():
+    pause_key = PrivateKey.generate()
+    client, operator_id, _ = setup_client()
+
+    token_id = create_token(client, operator_id, pause_key)
+
+    pause_token(client, token_id, pause_key)
+
+    print("\nAttempting to Unpause the token...")
+
+    unpause_tx = (
+        TokenUnpauseTransaction()
+        .set_token_id(token_id)
+        .freeze_with(client)
+        .sign(pause_key)
+    )
+    receipt = unpause_tx.execute(client)
+
+    try:
+        if receipt.status == ResponseCode.SUCCESS:
+            print(f"✅ Successfully unpaused token: {token_id}")
+            check_pause_status(client, token_id)
+        else:
+            print(f"❌ Transaction completed, but status is: {receipt.status.name}")
+            sys.exit(1)
+    except Exception as e:
+        print(f"❌ Error pausing token: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    unpause_token()

src/hiero_sdk_python/__init__.py

@@ -47,6 +47,8 @@
 from .tokens.token_nft_allowance import TokenNftAllowance
 from .tokens.hbar_allowance import HbarAllowance
 from .tokens.hbar_transfer import HbarTransfer
+from .tokens.token_unpause_transaction import TokenUnpauseTransaction
+from .tokens.token_pause_transaction import TokenPauseTransaction
 
 # Transaction
 from .transaction.transaction import Transaction
@@ -187,6 +189,8 @@
     "TokenNftAllowance",
     "HbarAllowance",
     "HbarTransfer",
+    "TokenPauseTransaction",
+    "TokenUnpauseTransaction",
 
     # Transaction
     "Transaction",

src/hiero_sdk_python/tokens/token_unpause_transaction.py

@@ -0,0 +1,133 @@
+"""
+hiero_sdk_python.tokens.token_unpause_transaction.py
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Provides the TokenUnpauseTransaction class a subclass of Transaction that
+facilitates unpausing a specified token on the Hedera network using the
+Hedera Token Service (HTS) API.
+"""
+from typing import Optional
+from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import (
+    SchedulableTransactionBody
+)
+from hiero_sdk_python.hapi.services.token_unpause_pb2 import TokenUnpauseTransactionBody
+from hiero_sdk_python.hapi.services.transaction_pb2 import TransactionBody
+
+from hiero_sdk_python.channels import _Channel
+from hiero_sdk_python.executable import _Method
+from hiero_sdk_python.client.client import Client
+from hiero_sdk_python.tokens.token_id import TokenId
+from hiero_sdk_python.transaction.transaction import Transaction
+
+class TokenUnpauseTransaction(Transaction):
+    """
+    Represents a token unpause transaction on the Hedera network.
+    
+    This transaction unpauses specified tokens.
+    
+    Inherits from the base Transaction class and implements the required methods
+    to build and execute a token unpause transaction.
+    """
+
+    def __init__(self, token_id: Optional[TokenId] = None) -> None:
+        """
+        Initializes a new TokenUnpauseTransaction instance with default values.
+
+        Args:
+            token_id (Optional[TokenId]): The ID of the token to unpause.
+        """
+        super().__init__()
+        self.token_id:  Optional[TokenId] = None
+
+        if token_id is not None:
+            self.set_token_id(token_id)
+
+    def set_token_id(self, token_id: TokenId) -> "TokenUnpauseTransaction":
+        """
+        Sets the token ID for this unpause transaction.
+
+        Args:
+            token_id (TokenId): The ID of the token to unpause.
+            
+        Returns:
+            TokenUnpauseTransaction: This current instance of transaction.
+        """
+        self._require_not_frozen()
+
+        #Check if the tokenId is instance of TokenId
+        if not isinstance(token_id, TokenId):
+            raise TypeError("token_id must be an instance of TokenId")
+
+        self.token_id = token_id
+        return self
+
+    def _validate_checksum(self, client: "Client") -> None:
+        """
+        Validates the checksum for the token ID associated with this transaction.
+
+        Args:
+            client (Client): The client instance used for validation.
+        """
+        if self.token_id is not None:
+            self.token_id.validate_checksum(client)
+
+    @classmethod
+    def _from_proto(cls, proto: TokenUnpauseTransactionBody) -> "TokenUnpauseTransaction":
+        """
+        Construct TokenUnpauseTransaction from TokenUnpauseTransactionBody.
+
+        Args:
+            proto (TokenUnpauseTransactionBody): The protobuf body of TokenUnpauseTransaction
+        
+        Returns:
+            TokenUnpauseTransaction: A new instance of TokenUnpauseTransaction
+        """
+        token_id = TokenId._from_proto(proto.token) if proto.token else None
+        return cls(token_id=token_id)
+
+    def _build_proto_body(self) -> TokenUnpauseTransactionBody:
+        """
+        Returns the protobuf body for the token unpause transaction.
+        
+        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()
+        )
+
+    def build_transaction_body(self) -> TransactionBody:
+        """
+        Builds and returns the protobuf transaction body for token unpause.
+
+        Returns:
+            TransactionBody: The protobuf transaction body containing the token unpause details.
+        """
+        token_unpause_body = self._build_proto_body()
+        transaction_body = self.build_base_transaction_body()
+        transaction_body.token_unpause.CopyFrom(token_unpause_body)
+        return transaction_body
+
+    def build_scheduled_body(self) -> SchedulableTransactionBody:
+        """
+        Builds the scheduled transaction body for this token unpause transaction.
+
+        Returns:
+            SchedulableTransactionBody: The built scheduled transaction body.
+        """
+        token_unpause_body = self._build_proto_body()
+        schedulable_body = self.build_base_scheduled_body()
+        schedulable_body.token_unpause.CopyFrom(token_unpause_body)
+        return schedulable_body
+
+    def _get_method(self, channel: _Channel) -> _Method:
+        return _Method(
+            transaction_func=channel.token.unpauseToken,
+            query_func=None
+        )