feat: add add_token_id() and add_nft_id() to TokenRejectTransaction (#2439)

Signed-off-by: cheese-cakee <farzanaman99@gmail.com>

Author: cheese-cakee

src/hiero_sdk_python/tokens/token_reject_transaction.py

@@ -52,8 +52,8 @@ def __init__(
         """
         super().__init__()
         self.owner_id: AccountId | None = owner_id
-        self.token_ids: list[TokenId] = token_ids if token_ids else []
-        self.nft_ids: list[NftId] = nft_ids if nft_ids else []
+        self.token_ids: list[TokenId] = list(token_ids) if token_ids else []
+        self.nft_ids: list[NftId] = list(nft_ids) if nft_ids else []
 
     def set_owner_id(self, owner_id: AccountId) -> TokenRejectTransaction:
         """Set the owner account ID for rejected tokens."""
@@ -64,13 +64,51 @@ def set_owner_id(self, owner_id: AccountId) -> TokenRejectTransaction:
     def set_token_ids(self, token_ids: list[TokenId]) -> TokenRejectTransaction:
         """Set the list of fungible token IDs to reject."""
         self._require_not_frozen()
-        self.token_ids = token_ids
+        self.token_ids = list(token_ids)
+        return self
+
+    def add_token_id(self, token_id: TokenId) -> TokenRejectTransaction:
+        """
+        Appends a fungible token ID to the list of tokens to reject.
+
+        Args:
+            token_id (TokenId): The fungible token ID to add.
+
+        Returns:
+            TokenRejectTransaction: This transaction instance (for chaining).
+
+        Raises:
+            TypeError: If token_id is not a TokenId instance.
+        """
+        self._require_not_frozen()
+        if not isinstance(token_id, TokenId):
+            raise TypeError("token_id must be a TokenId instance.")
+        self.token_ids.append(token_id)
         return self
 
     def set_nft_ids(self, nft_ids: list[NftId]) -> TokenRejectTransaction:
         """Set the list of NFT IDs to reject."""
         self._require_not_frozen()
-        self.nft_ids = nft_ids
+        self.nft_ids = list(nft_ids)
+        return self
+
+    def add_nft_id(self, nft_id: NftId) -> TokenRejectTransaction:
+        """
+        Appends an NFT ID to the list of NFTs to reject.
+
+        Args:
+            nft_id (NftId): The NFT ID to add.
+
+        Returns:
+            TokenRejectTransaction: This transaction instance (for chaining).
+
+        Raises:
+            TypeError: If nft_id is not a NftId instance.
+        """
+        self._require_not_frozen()
+        if not isinstance(nft_id, NftId):
+            raise TypeError("nft_id must be a NftId instance.")
+        self.nft_ids.append(nft_id)
         return self
 
     def _build_proto_body(self):

tests/unit/token_reject_transaction_test.py

@@ -142,6 +142,119 @@ def test_set_methods_require_not_frozen(mock_account_ids, nft_id, mock_client):
         reject_tx.set_nft_ids(nft_ids)
 
 
+def test_add_token_id(mock_account_ids):
+    """Test appending fungible token IDs one at a time."""
+    _, _, _, token_id_1, token_id_2 = mock_account_ids
+
+    reject_tx = TokenRejectTransaction()
+
+    # First append starts from the default empty list and returns self for chaining
+    tx_after_add = reject_tx.add_token_id(token_id_1)
+    assert tx_after_add is reject_tx
+    assert reject_tx.token_ids == [token_id_1]
+
+    # Second append preserves the existing entry and keeps insertion order
+    reject_tx.add_token_id(token_id_2)
+    assert reject_tx.token_ids == [token_id_1, token_id_2]
+
+
+def test_add_token_id_appends_to_preset_list(mock_account_ids):
+    """Test that add_token_id appends onto a list provided via the constructor/setter."""
+    _, _, _, token_id_1, token_id_2 = mock_account_ids
+
+    reject_tx = TokenRejectTransaction(token_ids=[token_id_1])
+    reject_tx.add_token_id(token_id_2)
+
+    assert reject_tx.token_ids == [token_id_1, token_id_2]
+
+
+def test_add_nft_id(mock_account_ids):
+    """Test appending NFT IDs one at a time."""
+    _, _, _, token_id, _ = mock_account_ids
+    nft_id_1 = NftId(token_id=token_id, serial_number=1)
+    nft_id_2 = NftId(token_id=token_id, serial_number=2)
+
+    reject_tx = TokenRejectTransaction()
+
+    # First append starts from the default empty list and returns self for chaining
+    tx_after_add = reject_tx.add_nft_id(nft_id_1)
+    assert tx_after_add is reject_tx
+    assert reject_tx.nft_ids == [nft_id_1]
+
+    # Second append preserves the existing entry and keeps insertion order
+    reject_tx.add_nft_id(nft_id_2)
+    assert reject_tx.nft_ids == [nft_id_1, nft_id_2]
+
+
+def test_add_methods_require_not_frozen(mock_account_ids, nft_id, mock_client):
+    """Test that add_token_id and add_nft_id are rejected once the transaction is frozen."""
+    _, _, _, token_id, _ = mock_account_ids
+
+    reject_tx = TokenRejectTransaction()
+    reject_tx.freeze_with(mock_client)
+
+    with pytest.raises(Exception, match="Transaction is immutable; it has been frozen"):
+        reject_tx.add_token_id(token_id)
+
+    with pytest.raises(Exception, match="Transaction is immutable; it has been frozen"):
+        reject_tx.add_nft_id(nft_id)
+
+
+def test_add_token_id_rejects_invalid_type(mock_account_ids):
+    """Test that add_token_id rejects a value that is not a TokenId instance."""
+    _, _, _, token_id, _ = mock_account_ids
+    nft_id = NftId(token_id=token_id, serial_number=1)
+
+    reject_tx = TokenRejectTransaction()
+
+    with pytest.raises(TypeError, match="token_id must be a TokenId instance."):
+        reject_tx.add_token_id(nft_id)
+
+    with pytest.raises(TypeError, match="token_id must be a TokenId instance."):
+        reject_tx.add_token_id("0.0.100")
+
+    # The invalid inputs must not have been appended.
+    assert reject_tx.token_ids == []
+
+
+def test_add_nft_id_rejects_invalid_type(mock_account_ids):
+    """Test that add_nft_id rejects a value that is not a NftId instance."""
+    _, _, _, token_id, _ = mock_account_ids
+
+    reject_tx = TokenRejectTransaction()
+
+    with pytest.raises(TypeError, match="nft_id must be a NftId instance."):
+        reject_tx.add_nft_id(token_id)
+
+    with pytest.raises(TypeError, match="nft_id must be a NftId instance."):
+        reject_tx.add_nft_id("0.0.100")
+
+    # The invalid inputs must not have been appended.
+    assert reject_tx.nft_ids == []
+
+
+def test_add_id_methods_do_not_mutate_caller_lists(mock_account_ids):
+    """Test that add_token_id/add_nft_id do not mutate lists passed to the constructor."""
+    _, _, _, token_id_1, token_id_2 = mock_account_ids
+    nft_id_1 = NftId(token_id=token_id_1, serial_number=1)
+    nft_id_2 = NftId(token_id=token_id_1, serial_number=2)
+
+    token_ids = [token_id_1]
+    nft_ids = [nft_id_1]
+
+    reject_tx = TokenRejectTransaction(token_ids=token_ids, nft_ids=nft_ids)
+    reject_tx.add_token_id(token_id_2)
+    reject_tx.add_nft_id(nft_id_2)
+
+    # The transaction reflects the appended IDs.
+    assert reject_tx.token_ids == [token_id_1, token_id_2]
+    assert reject_tx.nft_ids == [nft_id_1, nft_id_2]
+
+    # The caller's original lists remain untouched.
+    assert token_ids == [token_id_1]
+    assert nft_ids == [nft_id_1]
+
+
 def test_reject_transaction_can_execute(mock_account_ids):
     """Test that a reject transaction can be executed successfully."""
     account_id, owner_account_id, _, token_id, _ = mock_account_ids