feat(tck): add approveAllowance methods for the TCK module (hiero-ledger#2323)

danielmarv · web-flow · commit f2015e9a1d43 · 2026-06-03T09:39:59.000+01:00
Signed-off-by: Ntege Daniel &lt;danientege785@gmail.com&gt;
diff --git a/src/hiero_sdk_python/account/account_delete_transaction.py b/src/hiero_sdk_python/account/account_delete_transaction.py
@@ -85,18 +85,10 @@ def _build_proto_body(self):
         Returns:
             CryptoDeleteTransactionBody: The protobuf body for this transaction.
 
-        Raises:
-            ValueError: If account_id or transfer_account_id is not set.
         """
-        if self.account_id is None:
-            raise ValueError("Missing required AccountID")
-
-        if self.transfer_account_id is None:
-            raise ValueError("Missing AccountID for transfer")
-
         return CryptoDeleteTransactionBody(
-            deleteAccountID=self.account_id._to_proto(),
-            transferAccountID=(self.transfer_account_id._to_proto() if self.transfer_account_id else None),
+            deleteAccountID=(self.account_id._to_proto() if self.account_id is not None else None),
+            transferAccountID=(self.transfer_account_id._to_proto() if self.transfer_account_id is not None else None),
         )
 
     def build_transaction_body(self):
@@ -106,8 +98,6 @@ def build_transaction_body(self):
         Returns:
             TransactionBody: The built transaction body.
 
-        Raises:
-            ValueError: If account_id or transfer_account_id is not set.
         """
         account_delete_body = self._build_proto_body()
         transaction_body = self.build_base_transaction_body()
diff --git a/tck/handlers/__init__.py b/tck/handlers/__init__.py
@@ -4,6 +4,7 @@
 # Import all handler modules to trigger @rpc_method decorators
 from . import (
     account,
+    allowance,
     key,
     sdk,  # setup, reset
     topic,
diff --git a/tck/handlers/account.py b/tck/handlers/account.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from hiero_sdk_python.account.account_create_transaction import AccountCreateTransaction
+from hiero_sdk_python.account.account_delete_transaction import AccountDeleteTransaction
 from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.account.account_info import AccountInfo
 from hiero_sdk_python.account.account_update_transaction import AccountUpdateTransaction
@@ -13,9 +14,10 @@
 from hiero_sdk_python.timestamp import Timestamp
 from hiero_sdk_python.transaction.transaction_receipt import TransactionReceipt
 from tck.handlers.registry import rpc_method
-from tck.param.account import CreateAccountParams, GetAccountInfoParams, UpdateAccountParams
+from tck.param.account import CreateAccountParams, DeleteAccountParams, GetAccountInfoParams, UpdateAccountParams
 from tck.response.account import (
     CreateAccountResponse,
+    DeleteAccountResponse,
     GetAccountInfoResponse,
     StakingInfoResponse,
     TokenRelationshipResponse,
@@ -230,3 +232,25 @@ def get_account_info(params: GetAccountInfoParams) -> GetAccountInfoResponse:
 
     info = query.execute(client)
     return _build_account_info_response(info)
+
+
+@rpc_method("deleteAccount")
+def delete_account(params: DeleteAccountParams) -> DeleteAccountResponse:
+    """Delete an account using TCK deleteAccount parameters."""
+    client = get_client(params.sessionId)
+
+    transaction = AccountDeleteTransaction().set_grpc_deadline(DEFAULT_GRPC_TIMEOUT)
+
+    if params.deleteAccountId is not None:
+        transaction.set_account_id(AccountId.from_string(params.deleteAccountId))
+
+    if params.transferAccountId is not None:
+        transaction.set_transfer_account_id(AccountId.from_string(params.transferAccountId))
+
+    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 DeleteAccountResponse(status=ResponseCode(receipt.status).name)
diff --git a/tck/handlers/allowance.py b/tck/handlers/allowance.py
@@ -0,0 +1,131 @@
+"""TCK RPC handler for the approveAllowance endpoint."""
+
+from __future__ import annotations
+
+from hiero_sdk_python.account.account_allowance_approve_transaction import (
+    AccountAllowanceApproveTransaction,
+)
+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.util.client_utils import get_client
+from tck.util.constants import DEFAULT_GRPC_TIMEOUT
+
+
+def _build_approve_allowance_transaction(
+    params: ApproveAllowanceParams,
+) -> AccountAllowanceApproveTransaction:
+    """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:
+        _apply_allowance_entry(transaction, entry)
+
+    return transaction
+
+
+def _parse_optional_account_id(value: str | None) -> AccountId | None:
+    """Parse an optional account ID string, raising on empty string."""
+    if value is None:
+        return None
+    if not value.strip():
+        raise ValueError("Account ID cannot be an empty string")
+    return AccountId.from_string(value)
+
+
+def _apply_allowance_entry(
+    transaction: AccountAllowanceApproveTransaction,
+    entry: AllowanceEntry,
+) -> None:
+    """Apply a single allowance entry to the transaction."""
+    owner_account_id = _parse_optional_account_id(entry.ownerAccountId)
+    spender_account_id = _parse_optional_account_id(entry.spenderAccountId)
+
+    if entry.hbar is not None:
+        if entry.hbar.amount is None:
+            raise ValueError("hbar allowance requires an amount")
+        amount = int(entry.hbar.amount)
+        transaction.approve_hbar_allowance(
+            owner_account_id,
+            spender_account_id,
+            Hbar.from_tinybars(amount),
+        )
+
+    if entry.token is not None:
+        if entry.token.tokenId is None or entry.token.amount is None:
+            raise ValueError("token allowance requires tokenId and amount")
+        token_id = TokenId.from_string(entry.token.tokenId)
+        amount = int(entry.token.amount)
+        transaction.approve_token_allowance(
+            token_id,
+            owner_account_id,
+            spender_account_id,
+            amount,
+        )
+
+    if entry.nft is not None:
+        token_id = TokenId.from_string(entry.nft.tokenId)
+
+        if entry.nft.approvedForAll is True:
+            transaction.approve_token_nft_allowance_all_serials(
+                token_id,
+                owner_account_id,
+                spender_account_id,
+            )
+        elif entry.nft.approvedForAll is False:
+            transaction.delete_token_nft_allowance_all_serials(
+                token_id,
+                owner_account_id,
+                spender_account_id,
+            )
+        elif entry.nft.serialNumbers is not None:
+            delegating_spender = _parse_optional_account_id(entry.nft.delegateSpenderAccountId)
+
+            for serial in entry.nft.serialNumbers:
+                nft_id = NftId(token_id=token_id, serial_number=int(serial))
+                if delegating_spender is not None:
+                    transaction.approve_token_nft_allowance_with_delegating_spender(
+                        nft_id,
+                        owner_account_id,
+                        spender_account_id,
+                        delegating_spender,
+                    )
+                else:
+                    transaction.approve_token_nft_allowance(
+                        nft_id,
+                        owner_account_id,
+                        spender_account_id,
+                    )
+        else:
+            # 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,
+                owner_account_id,
+                spender_account_id,
+            )
+
+
+@rpc_method("approveAllowance")
+def approve_allowance(params: ApproveAllowanceParams) -> ApproveAllowanceResponse:
+    """Approve allowances using TCK approveAllowance parameters."""
+    client = get_client(params.sessionId)
+
+    transaction = _build_approve_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 ApproveAllowanceResponse(status=ResponseCode(receipt.status).name)
diff --git a/tck/param/account.py b/tck/param/account.py
@@ -85,6 +85,24 @@ def parse_json_params(cls, params: dict) -> UpdateAccountParams:
         )
 
 
+@dataclass
+class DeleteAccountParams(BaseTransactionParams):
+    """Request parameters for the deleteAccount endpoint."""
+
+    deleteAccountId: str | None = None
+    transferAccountId: str | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> DeleteAccountParams:
+        """Parse JSON-RPC params into a DeleteAccountParams instance."""
+        return cls(
+            deleteAccountId=params.get("deleteAccountId"),
+            transferAccountId=params.get("transferAccountId"),
+            sessionId=parse_session_id(params),
+            commonTransactionParams=parse_common_transaction_params(params),
+        )
+
+
 @dataclass
 class GetAccountInfoParams(BaseParams):
     """Request parameters for the getAccountInfo endpoint."""
diff --git a/tck/param/allowance.py b/tck/param/allowance.py
@@ -0,0 +1,103 @@
+"""TCK request parameter models for approveAllowance endpoint."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from tck.param.base import BaseTransactionParams
+from tck.util.param_utils import (
+    parse_common_transaction_params,
+    parse_session_id,
+    to_bool,
+)
+
+
+@dataclass
+class HbarAllowanceParams:
+    """Nested hbar allowance parameters."""
+
+    amount: str | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> HbarAllowanceParams:
+        return cls(amount=params.get("amount"))
+
+
+@dataclass
+class TokenAllowanceParams:
+    """Nested token allowance parameters."""
+
+    tokenId: str | None = None
+    amount: str | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> TokenAllowanceParams:
+        return cls(
+            tokenId=params.get("tokenId"),
+            amount=params.get("amount"),
+        )
+
+
+@dataclass
+class NftAllowanceParams:
+    """Nested NFT allowance parameters."""
+
+    tokenId: str | None = None
+    serialNumbers: list[str] | None = None
+    approvedForAll: bool | None = None
+    delegateSpenderAccountId: str | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> NftAllowanceParams:
+        return cls(
+            tokenId=params.get("tokenId"),
+            serialNumbers=params.get("serialNumbers"),
+            approvedForAll=to_bool(params.get("approvedForAll")),
+            delegateSpenderAccountId=params.get("delegateSpenderAccountId"),
+        )
+
+
+@dataclass
+class AllowanceEntry:
+    """A single allowance entry in the allowances list."""
+
+    ownerAccountId: str | None = None
+    spenderAccountId: str | None = None
+    hbar: HbarAllowanceParams | None = None
+    token: TokenAllowanceParams | None = None
+    nft: NftAllowanceParams | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> AllowanceEntry:
+        hbar = params.get("hbar")
+        token = params.get("token")
+        nft = params.get("nft")
+
+        return cls(
+            ownerAccountId=params.get("ownerAccountId"),
+            spenderAccountId=params.get("spenderAccountId"),
+            hbar=HbarAllowanceParams.parse_json_params(hbar) if hbar is not None else None,
+            token=TokenAllowanceParams.parse_json_params(token) if token is not None else None,
+            nft=NftAllowanceParams.parse_json_params(nft) if nft is not None else None,
+        )
+
+
+@dataclass
+class ApproveAllowanceParams(BaseTransactionParams):
+    """Request parameters for the approveAllowance endpoint."""
+
+    allowances: list[AllowanceEntry] | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> ApproveAllowanceParams:
+        """Parse JSON-RPC params into an ApproveAllowanceParams instance."""
+        raw_allowances = params.get("allowances")
+        allowances = None
+        if raw_allowances is not None:
+            allowances = [AllowanceEntry.parse_json_params(entry) for entry in raw_allowances]
+
+        return cls(
+            allowances=allowances,
+            sessionId=parse_session_id(params),
+            commonTransactionParams=parse_common_transaction_params(params),
+        )
diff --git a/tck/response/account.py b/tck/response/account.py
@@ -20,6 +20,13 @@ class UpdateAccountResponse:
     status: str | None = None
 
 
+@dataclass
+class DeleteAccountResponse:
+    """Response payload for deleteAccount."""
+
+    status: str | None = None
+
+
 @dataclass
 class StakingInfoResponse:
     """Nested staking fields in the getAccountInfo response."""
diff --git a/tck/response/allowance.py b/tck/response/allowance.py
@@ -0,0 +1,12 @@
+"""TCK response models for approveAllowance endpoint."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ApproveAllowanceResponse:
+    """Response payload for approveAllowance."""
+
+    status: str | None = None
diff --git a/tests/unit/account_delete_transaction_test.py b/tests/unit/account_delete_transaction_test.py
