Create ChunkedTransaction class

Signed-off-by: MonaaEid <monaa_eid@hotmail.com>

Author: MonaaEid

.github/workflows/pr-check-primary-codeql.yml

@@ -42,7 +42,7 @@ jobs:
                   egress-policy: audit
 
             - name: Initialize CodeQL
-              uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+              uses: github/codeql-action/init@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
               with:
                   languages: ${{ matrix.language }}
                   build-mode: ${{ matrix.build-mode }}
@@ -66,6 +66,6 @@ jobs:
               run: uv sync --frozen --all-groups --all-packages --all-extras
 
             - name: Perform CodeQL Analysis
-              uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+              uses: github/codeql-action/analyze@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
               with:
                   category: "/language:${{matrix.language}}"

src/hiero_sdk_python/file/file_append_transaction.py

@@ -39,10 +39,15 @@ def __init__(
         super().__init__()
         self.file_id: FileId | None = file_id
         self.contents: bytes | None = self._encode_contents(contents)
-        self.max_chunks: int = max_chunks if max_chunks is not None else 20
-        self.chunk_size: int = chunk_size if chunk_size is not None else 4096
+        self.max_chunks: int = 20
+        self.chunk_size: int = 4096
         self._default_transaction_fee = Hbar(5).to_tinybars()
 
+        if max_chunks is not None:
+            self.set_max_chunks(max_chunks)
+        if chunk_size is not None:
+            self.set_chunk_size(chunk_size)
+ 
         self._total_chunks = self._calculate_total_chunks()
 
     def _encode_contents(self, contents: str | bytes | None) -> bytes | None:
@@ -121,8 +126,7 @@ def set_max_chunks(self, max_chunks: int) -> FileAppendTransaction:
         Returns:
             FileAppendTransaction: This transaction instance.
         """
-        self._require_not_frozen()
-        self.max_chunks = max_chunks
+        super().set_max_chunks(max_chunks)
         return self
 
     def set_chunk_size(self, chunk_size: int) -> FileAppendTransaction:
@@ -135,8 +139,7 @@ def set_chunk_size(self, chunk_size: int) -> FileAppendTransaction:
         Returns:
             FileAppendTransaction: This transaction instance.
         """
-        self._require_not_frozen()
-        self.chunk_size = chunk_size
+        super().set_max_chunks(max_chunks)
         self._total_chunks = self._calculate_total_chunks()
         return self
 

src/hiero_sdk_python/transaction/chunked_transaction.py

@@ -12,10 +12,6 @@
 from hiero_sdk_python.transaction.transaction_response import TransactionResponse
 
 
-if TYPE_CHECKING:
-    pass
-
-
 class ChunkedTransaction(Transaction, ABC):
     """
     Abstract base class for transactions that support chunking.
@@ -43,17 +39,6 @@ def __init__(self) -> None:
         self.chunk_size: int = 1024
         self.max_chunks: int = 20
 
-    @abstractmethod
-    def get_required_chunks(self) -> int:
-        """
-        Returns the number of chunks required for the current content.
-
-        Subclasses must implement this based on their content type.
-
-        Returns:
-            int: Number of chunks required.
-        """
-        pass
 
     @abstractmethod
     def _build_proto_body(self):
@@ -148,10 +133,9 @@ def freeze_with(self, client: Client) -> ChunkedTransaction:
         if self._transaction_body_bytes:
             return self
 
-        self._validate_chunking()
         self._resolve_transaction_id(client)
 
-        if self.transaction_id is None or self.transaction_id.valid_start is None:
+        if self.transaction_id.valid_start is None:
             raise ValueError("Transaction ID with valid_start must be set before freezing chunked transaction.")
 
         # Generate transaction IDs for all chunks if not already done
@@ -265,11 +249,10 @@ def execute_all(
             List[TransactionReceipt]: If wait_for_receipt is True (default)
             List[TransactionResponse]: If wait_for_receipt is False
         """
-        self._validate_chunking()
-
-        required_chunks = self.get_required_chunks()
+        self._validate_chunking() # Moved here
 
-        if required_chunks == 1:
+        # For single-chunk transactions, delegate to the standard execution flow.
+        if self.get_required_chunks() == 1:
             return [
                 super().execute(
                     client,
@@ -279,13 +262,14 @@ def execute_all(
                 )
             ]
 
-        # Ensure the initial transaction ID and chunk transaction IDs exist.
-        if not self._transaction_ids:
+        # For multi-chunk transactions, ensure we are frozen before proceeding.
+        if not self._transaction_body_bytes:
             self.freeze_with(client)
 
         responses = []
+        required_chunks = self.get_required_chunks()
 
-        for chunk_index in range(required_chunks):
+        for chunk_index in range(self.get_required_chunks()):
             self._current_chunk_index = chunk_index
 
             if chunk_index < len(self._transaction_ids):

tck/handlers/token.py

@@ -13,6 +13,8 @@
 from hiero_sdk_python.tokens.fee_assessment_method import FeeAssessmentMethod
 from hiero_sdk_python.tokens.nft_id import NftId
 from hiero_sdk_python.tokens.supply_type import SupplyType
+from hiero_sdk_python.tokens.token_airdrop_claim import TokenClaimAirdropTransaction
+from hiero_sdk_python.tokens.token_airdrop_pending_id import PendingAirdropId
 from hiero_sdk_python.tokens.token_airdrop_transaction import TokenAirdropTransaction
 from hiero_sdk_python.tokens.token_associate_transaction import TokenAssociateTransaction
 from hiero_sdk_python.tokens.token_create_transaction import TokenCreateTransaction
@@ -28,6 +30,7 @@
 from tck.param.token import (
     AirdropTokenParams,
     AssociateTokenParams,
+    ClaimTokenParams,
     CreateTokenParams,
     DeleteTokenParams,
     FreezeTokenParams,
@@ -37,6 +40,7 @@
 from tck.response.token import (
     AirdropTokenResponse,
     AssociateTokenResponse,
+    ClaimTokenResponse,
     CreateTokenResponse,
     DeleteTokenResponse,
     FreezeTokenResponse,
@@ -429,3 +433,48 @@ def airdrop_token(params: AirdropTokenParams) -> AirdropTokenResponse:
     )
 
     return AirdropTokenResponse(status=ResponseCode(receipt.status).name)
+
+
+def _build_claim_token_transaction(params: ClaimTokenParams) -> TokenClaimAirdropTransaction:
+    """Build a TokenClaimAirdropTransaction from TCK params."""
+    transaction = TokenClaimAirdropTransaction().set_grpc_deadline(DEFAULT_GRPC_TIMEOUT)
+
+    sender_id = AccountId.from_string(params.senderAccountId)
+    receiver_id = AccountId.from_string(params.receiverAccountId)
+    token_id = TokenId.from_string(params.tokenId)
+
+    if params.serialNumbers:
+        for serial_number in params.serialNumbers:
+            transaction.add_pending_airdrop_id(
+                PendingAirdropId(
+                    sender_id=sender_id,
+                    receiver_id=receiver_id,
+                    nft_id=NftId(token_id=token_id, serial_number=int(serial_number)),
+                )
+            )
+    else:
+        transaction.add_pending_airdrop_id(
+            PendingAirdropId(
+                sender_id=sender_id,
+                receiver_id=receiver_id,
+                token_id=token_id,
+            )
+        )
+
+    return transaction
+
+
+@rpc_method("claimToken")
+def claim_token(params: ClaimTokenParams) -> ClaimTokenResponse:
+    """Claim pending token airdrops using TCK claimToken parameters."""
+    client = get_client(params.sessionId)
+
+    transaction = _build_claim_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 ClaimTokenResponse(status=ResponseCode(receipt.status).name)

tck/param/token.py

@@ -204,3 +204,31 @@ def parse_json_params(cls, params: dict) -> AirdropTokenParams:
             sessionId=parse_session_id(params),
             commonTransactionParams=parse_common_transaction_params(params),
         )
+
+
+@dataclass
+class ClaimTokenParams(BaseTransactionParams):
+    """Request parameters for the claimToken endpoint."""
+
+    senderAccountId: str | None = None
+    receiverAccountId: str | None = None
+    tokenId: str | None = None
+    serialNumbers: list[str] | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> ClaimTokenParams:
+        """Parse JSON-RPC params into a ClaimTokenParams instance."""
+        serial_numbers = params.get("serialNumbers")
+        if serial_numbers is not None and not isinstance(serial_numbers, list):
+            raise ValueError("serialNumbers must be a list")
+        if serial_numbers is not None and any(not isinstance(serial_number, str) for serial_number in serial_numbers):
+            raise ValueError("each serialNumbers item must be a string")
+
+        return cls(
+            senderAccountId=params.get("senderAccountId"),
+            receiverAccountId=params.get("receiverAccountId"),
+            tokenId=params.get("tokenId"),
+            serialNumbers=serial_numbers,
+            sessionId=parse_session_id(params),
+            commonTransactionParams=parse_common_transaction_params(params),
+        )

tck/response/token.py

@@ -47,3 +47,8 @@ class PauseTokenResponse(StatusOnlyResponse):
 @dataclass
 class AirdropTokenResponse(StatusOnlyResponse):
     """Response payload for airdropToken."""
+
+
+@dataclass
+class ClaimTokenResponse(StatusOnlyResponse):
+    """Response payload for claimToken."""

tests/integration/topic_message_submit_transaction_e2e_test.py

@@ -108,7 +108,7 @@ def test_topic_message_submit_transaction_fails_if_max_chunks_less_than_requied(
     message_tx = TopicMessageSubmitTransaction().set_topic_id(topic_id).set_message(message).set_max_chunks(2)
 
     with pytest.raises(ValueError):
-        message_tx.freeze_with(env.client)
+        message_tx.execute(env.client)
 
     delete_topic(env.client, topic_id)
 
@@ -289,7 +289,7 @@ def test_integration_topic_message_submit_transaction_fails_if_required_chunk_gr
     with pytest.raises(
         ValueError, match="Message requires 4 chunks but max_chunks=2. Increase limit with set_max_chunks()."
     ):
-        message_transaction.freeze_with(env.client)
+        message_transaction.execute(env.client)
 
     delete_topic(env.client, topic_id)