feat(tck): Add tck method for deleteAllowance (hiero-ledger#2338)

Signed-off-by: Ntege Daniel <danientege785@gmail.com>

Author: danielmarv

src/hiero_sdk_python/tokens/token_associate_transaction.py

@@ -96,15 +96,10 @@ def _build_proto_body(self) -> token_associate_pb2.TokenAssociateTransactionBody
 
         Returns:
             TokenAssociateTransactionBody: The protobuf body for this transaction.
-
-        Raises:
-            ValueError: If account ID or token IDs are not set.
         """
-        if not self.account_id or not self.token_ids:
-            raise ValueError("Account ID and token IDs must be set.")
-
         return token_associate_pb2.TokenAssociateTransactionBody(
-            account=self.account_id._to_proto(), tokens=[token_id._to_proto() for token_id in self.token_ids]
+            account=self.account_id._to_proto() if self.account_id else None,
+            tokens=[token_id._to_proto() for token_id in (self.token_ids or [])],
         )
 
     @classmethod

src/hiero_sdk_python/tokens/token_create_transaction.py

@@ -5,16 +5,15 @@
 Module for creating and validating Hedera token transactions.
 
 This module includes:
-- TokenCreateValidator: Validates token creation parameters.
 - TokenParams: Represents token attributes.
 - TokenKeys: Represents cryptographic keys for tokens.
 - TokenCreateTransaction: Handles token creation transactions on Hedera.
 """
 
 from __future__ import annotations
 
+import ctypes
 from dataclasses import dataclass, field
-from typing import Any
 
 from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.channels import _Channel
@@ -104,101 +103,6 @@ class TokenKeys:
     fee_schedule_key: Key | None = None
 
 
-class TokenCreateValidator:
-    """Token, key and freeze checks for creating a token as per the proto."""
-
-    @staticmethod
-    def _validate_token_params(token_params: TokenParams) -> None:
-        """Ensure valid values for the token characteristics."""
-        TokenCreateValidator._validate_required_fields(token_params)
-        TokenCreateValidator._validate_name_and_symbol(token_params)
-        TokenCreateValidator._validate_initial_supply(token_params)
-        TokenCreateValidator._validate_decimals_and_token_type(token_params)
-        TokenCreateValidator._validate_supply_max_and_type(token_params)
-
-    @staticmethod
-    def _validate_token_freeze_status(keys: TokenKeys, token_params: TokenParams) -> None:
-        """Ensure account is not frozen for this token."""
-        if token_params.freeze_default and not keys.freeze_key:
-            raise ValueError("Token is permanently frozen. Unable to proceed.")
-            # freezeDefault=True simply starts accounts frozen; allow creation as long as
-            # a freeze key exists so the treasury (and others) can be unfrozen later.
-
-    @staticmethod
-    def _validate_required_fields(token_params: TokenParams) -> None:
-        """Ensure all required fields are present and not empty."""
-        required_fields: dict[str, Any] = {
-            "Token name": token_params.token_name,
-            "Token symbol": token_params.token_symbol,
-            "Treasury account ID": token_params.treasury_account_id,
-        }
-        for _field, _value in required_fields.items():
-            if not _value:
-                raise ValueError(f"{_field} is required")
-
-    @staticmethod
-    def _validate_name_and_symbol(token_params: TokenParams) -> None:
-        """Ensure the token name & symbol are valid in length and do not contain a NUL character."""
-        if len(token_params.token_name.encode()) > 100:
-            raise ValueError("Token name must be between 1 and 100 bytes")
-        if len(token_params.token_symbol.encode()) > 100:
-            raise ValueError("Token symbol must be between 1 and 100 bytes")
-
-        # Ensure the token name and symbol do not contain a NUL character
-        for attr in ["token_name", "token_symbol"]:
-            if "\x00" in getattr(token_params, attr):
-                raise ValueError(f"{attr.replace('_', ' ').capitalize()} must not contain the Unicode NUL character")
-
-    @staticmethod
-    def _validate_initial_supply(token_params: TokenParams) -> None:
-        """Ensure initial supply is a non-negative integer and does not exceed max supply."""
-        MAXIMUM_SUPPLY = 9_223_372_036_854_775_807  # 2^63 - 1
-
-        if token_params.initial_supply < 0:
-            raise ValueError("Initial supply must be a non-negative integer")
-        if token_params.initial_supply > MAXIMUM_SUPPLY:
-            raise ValueError(f"Initial supply cannot exceed {MAXIMUM_SUPPLY}")
-        if token_params.max_supply > MAXIMUM_SUPPLY:
-            raise ValueError(f"Max supply cannot exceed {MAXIMUM_SUPPLY}")
-
-    @staticmethod
-    def _validate_decimals_and_token_type(token_params: TokenParams) -> None:
-        """Ensure decimals and token_type align with either fungible or non-fungible constraints."""
-        if token_params.decimals < 0:
-            raise ValueError("Decimals must be a non-negative integer")
-
-        if token_params.token_type == TokenType.FUNGIBLE_COMMON:
-            # Fungible tokens must have an initial supply > 0
-            if token_params.initial_supply <= 0:
-                raise ValueError("A Fungible Token requires an initial supply greater than zero")
-
-        elif token_params.token_type == TokenType.NON_FUNGIBLE_UNIQUE:
-            # Non-fungible tokens must have zero decimals and zero initial supply
-            if token_params.decimals != 0:
-                raise ValueError("A Non-fungible Unique Token must have zero decimals")
-            if token_params.initial_supply != 0:
-                raise ValueError("A Non-fungible Unique Token requires an initial supply of zero")
-
-    @staticmethod
-    def _validate_supply_max_and_type(token_params: TokenParams) -> None:
-        """Ensure max supply and supply type constraints."""
-        # An infinite token must have max supply = 0.
-        # A finite token must have max supply > 0.
-        # Setting a max supply is only approprite for a finite token.
-        if token_params.max_supply != 0 and token_params.supply_type != SupplyType.FINITE:
-            raise ValueError("Setting a max supply field requires setting a finite supply type")
-
-        # Finite tokens have the option to set a max supply >0.
-        # A finite token must have max supply > 0.
-        if token_params.supply_type == SupplyType.FINITE:
-            if token_params.max_supply <= 0:
-                raise ValueError("A finite supply token requires max_supply greater than zero 0")
-
-            # Ensure max supply is greater than initial supply
-            if token_params.initial_supply > token_params.max_supply:
-                raise ValueError("Initial supply cannot exceed the defined max supply for a finite token")
-
-
 class TokenCreateTransaction(Transaction):
     """
     Represents a token creation transaction on the Hedera network.
@@ -473,12 +377,6 @@ def _build_proto_body(self) -> token_create_pb2.TokenCreateTransactionBody:
         Raises:
             ValueError: If required fields are missing or invalid.
         """
-        # Validate all token params
-        TokenCreateValidator._validate_token_params(self._token_params)
-
-        # Validate freeze status
-        TokenCreateValidator._validate_token_freeze_status(self._keys, self._token_params)
-
         # Convert keys
         admin_key_proto = key_to_proto(self._keys.admin_key)
         supply_key_proto = key_to_proto(self._keys.supply_key)
@@ -505,8 +403,8 @@ def _build_proto_body(self) -> token_create_pb2.TokenCreateTransactionBody:
         return token_create_pb2.TokenCreateTransactionBody(
             name=self._token_params.token_name,
             symbol=self._token_params.token_symbol,
-            decimals=self._token_params.decimals,
-            initialSupply=self._token_params.initial_supply,
+            decimals=ctypes.c_uint32(self._token_params.decimals).value,
+            initialSupply=ctypes.c_uint64(self._token_params.initial_supply).value,
             tokenType=token_type_value,
             supplyType=supply_type_value,
             maxSupply=self._token_params.max_supply,

src/hiero_sdk_python/tokens/token_freeze_transaction.py

@@ -76,18 +76,10 @@ def _build_proto_body(self) -> token_freeze_account_pb2.TokenFreezeAccountTransa
 
         Returns:
             TokenFreezeAccountTransactionBody: The protobuf body for this transaction.
-
-        Raises:
-            ValueError: If the token ID or account ID is missing.
         """
-        if not self.token_id:
-            raise ValueError("Missing required TokenID.")
-
-        if not self.account_id:
-            raise ValueError("Missing required AccountID.")
-
         return token_freeze_account_pb2.TokenFreezeAccountTransactionBody(
-            token=self.token_id._to_proto(), account=self.account_id._to_proto()
+            token=self.token_id._to_proto() if self.token_id else None,
+            account=self.account_id._to_proto() if self.account_id else None,
         )
 
     def build_transaction_body(self) -> transaction_pb2.TransactionBody:

src/hiero_sdk_python/tokens/token_mint_transaction.py

@@ -94,45 +94,21 @@ def set_metadata(self, metadata: bytes | list[bytes]) -> TokenMintTransaction:
         self.metadata = metadata
         return self
 
-    def _validate_parameters(self):
-        """Validates the parameters for the token mint transaction."""
-        if self.token_id is None:
-            raise ValueError("Token ID is required for minting.")
-
-        if (self.amount is not None) and (self.metadata is not None):
-            raise ValueError("Specify either amount for fungible tokens or metadata for NFTs, not both.")
-
     def _build_proto_body(self) -> token_mint_pb2.TokenMintTransactionBody:
         """
         Returns the protobuf body for the token mint transaction (fungible or NFT).
-
-        Raises:
-            ValueError: If required fields are missing or conflicting.
         """
-        self._validate_parameters()
+        token_proto = self.token_id._to_proto() if self.token_id else None
+        tx_body = token_mint_pb2.TokenMintTransactionBody(token=token_proto)
 
         if self.amount is not None:
-            if self.amount <= 0:
-                raise ValueError("Amount to mint must be positive.")
-            # Fungible token
-            return token_mint_pb2.TokenMintTransactionBody(
-                token=self.token_id._to_proto(),
-                amount=self.amount,
-                metadata=[],
-            )
+            tx_body.amount = self.amount
 
         if self.metadata is not None:
-            # NFT
-            if not isinstance(self.metadata, list):
-                raise ValueError("Metadata must be a list of byte arrays for NFTs.")
-            if not self.metadata:
-                raise ValueError("Metadata list cannot be empty for NFTs.")
-            return token_mint_pb2.TokenMintTransactionBody(
-                token=self.token_id._to_proto(), amount=0, metadata=self.metadata
-            )
-
-        # Neither amount nor metadata is set
-        raise ValueError("Specify either amount for fungible tokens or metadata for NFTs.")
+            metadata = [self.metadata] if isinstance(self.metadata, bytes) else self.metadata
+            tx_body.metadata.extend(metadata)
+
+        return tx_body
 
     def build_transaction_body(self) -> transaction_pb2.TransactionBody:
         """

src/hiero_sdk_python/tokens/token_pause_transaction.py

@@ -63,14 +63,8 @@ def _build_proto_body(self) -> token_pause_pb2.TokenPauseTransactionBody:
 
         Returns:
             TokenPauseTransactionBody: The protobuf body for this transaction.
-
-        Raises:
-            ValueError: If no token_id has been set.
         """
-        if self.token_id is None or self.token_id.num == 0:
-            raise ValueError("token_id must be set before building the transaction body")
-
-        return TokenPauseTransactionBody(token=self.token_id._to_proto())
+        return TokenPauseTransactionBody(token=self.token_id._to_proto() if self.token_id else None)
 
     def build_transaction_body(self) -> transaction_pb2.TransactionBody:
         """

src/hiero_sdk_python/transaction/transaction_receipt.py

@@ -110,6 +110,16 @@ def serial_numbers(self) -> list[int]:
         """
         return cast(list[int], self._receipt_proto.serialNumbers)
 
+    @property
+    def new_total_supply(self) -> int:
+        """
+        Returns the token's total supply after a mint or burn transaction.
+
+        Returns:
+            int: The new total token supply, or 0 when not present.
+        """
+        return self._receipt_proto.newTotalSupply
+
     @property
     def file_id(self) -> FileId | None:
         """

tck/handlers/__init__.py

@@ -7,6 +7,7 @@
     allowance,
     key,
     sdk,  # setup, reset
+    token,
     topic,
 )
 from .registry import (

tck/handlers/allowance.py

@@ -1,19 +1,27 @@
-"""TCK RPC handler for the approveAllowance endpoint."""
+"""TCK RPC handlers for allowance endpoints."""
 
 from __future__ import annotations
 
 from hiero_sdk_python.account.account_allowance_approve_transaction import (
     AccountAllowanceApproveTransaction,
 )
+from hiero_sdk_python.account.account_allowance_delete_transaction import (
+    AccountAllowanceDeleteTransaction,
+)
 from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.hbar import Hbar
 from hiero_sdk_python.response_code import ResponseCode
 from hiero_sdk_python.tokens.nft_id import NftId
 from hiero_sdk_python.tokens.token_id import TokenId
 from hiero_sdk_python.transaction.transaction_receipt import TransactionReceipt
 from tck.handlers.registry import rpc_method
-from tck.param.allowance import AllowanceEntry, ApproveAllowanceParams
-from tck.response.allowance import ApproveAllowanceResponse
+from tck.param.allowance import (
+    AllowanceEntry,
+    ApproveAllowanceParams,
+    DeleteAllowanceEntry,
+    DeleteAllowanceParams,
+)
+from tck.response.allowance import ApproveAllowanceResponse, DeleteAllowanceResponse
 from tck.util.client_utils import get_client
 from tck.util.constants import DEFAULT_GRPC_TIMEOUT
 
@@ -24,10 +32,7 @@ def _build_approve_allowance_transaction(
     """Build an AccountAllowanceApproveTransaction from TCK params."""
     transaction = AccountAllowanceApproveTransaction().set_grpc_deadline(DEFAULT_GRPC_TIMEOUT)
 
-    if not params.allowances:
-        raise ValueError("allowances list cannot be empty")
-
-    for entry in params.allowances:
+    for entry in params.allowances or []:
         _apply_allowance_entry(transaction, entry)
 
     return transaction
@@ -106,7 +111,7 @@ def _apply_allowance_entry(
                         spender_account_id,
                     )
         else:
-            # nft object present with only tokenId — this is DeleteNftAllowanceAllSerials
+            # nft object present with only tokenId - this is DeleteNftAllowanceAllSerials
             # with no approvedForAll field (defaults to delete)
             transaction.delete_token_nft_allowance_all_serials(
                 token_id,
@@ -129,3 +134,51 @@ def approve_allowance(params: ApproveAllowanceParams) -> ApproveAllowanceRespons
     receipt: TransactionReceipt = response.get_receipt(client, validate_status=True)
 
     return ApproveAllowanceResponse(status=ResponseCode(receipt.status).name)
+
+
+def _build_delete_allowance_transaction(
+    params: DeleteAllowanceParams,
+) -> AccountAllowanceDeleteTransaction:
+    """Build an AccountAllowanceDeleteTransaction from TCK params."""
+    transaction = AccountAllowanceDeleteTransaction().set_grpc_deadline(DEFAULT_GRPC_TIMEOUT)
+
+    for entry in params.allowances or []:
+        _apply_delete_allowance_entry(transaction, entry)
+
+    return transaction
+
+
+def _apply_delete_allowance_entry(
+    transaction: AccountAllowanceDeleteTransaction,
+    entry: DeleteAllowanceEntry,
+) -> None:
+    """Apply a single delete allowance entry to the transaction."""
+    owner_account_id = _parse_optional_account_id(entry.ownerAccountId)
+
+    if entry.tokenId is None:
+        raise ValueError("NFT allowance requires a tokenId")
+
+    if not entry.tokenId.strip():
+        raise ValueError("Token ID cannot be an empty string")
+
+    token_id = TokenId.from_string(entry.tokenId)
+
+    for serial in entry.serialNumbers or []:
+        nft_id = NftId(token_id=token_id, serial_number=int(serial))
+        transaction.delete_all_token_nft_allowances(nft_id, owner_account_id)
+
+
+@rpc_method("deleteAllowance")
+def delete_allowance(params: DeleteAllowanceParams) -> DeleteAllowanceResponse:
+    """Delete allowances using TCK deleteAllowance parameters."""
+    client = get_client(params.sessionId)
+
+    transaction = _build_delete_allowance_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 DeleteAllowanceResponse(status=ResponseCode(receipt.status).name)