feat(tck): implement revokeTokenKyc JSON-RPC method

[exploreriii]

Problem revokeTokenKyc is missing; the driver's TokenRevokeKycTransaction suites cannot run.

Solution Mirror grantTokenKyc (Issue 5 — implement that first or coordinate).

Spec: https://github.com/hiero-ledger/hiero-sdk-tck/blob/main/docs/test-specifications/token-service/TokenRevokeKycTransaction.md
JS reference: https://github.com/hiero-ledger/hiero-sdk-js/blob/main/tck/methods/token.ts (revokeTokenKyc)
SDK class: TokenRevokeKycTransaction

[github-actions]

Thanks for your submission.

This issue is awaiting approval from @hiero-ledger/hiero-sdk-python-triage and @hiero-ledger/hiero-sdk-python-committers and @hiero-ledger/hiero-sdk-python-maintainers.

[github-actions]

Approved by @hiero-ledger/hiero-sdk-python-triage and @hiero-ledger/hiero-sdk-python-committers and @hiero-ledger/hiero-sdk-python-maintainers.

[github-actions]

@coderabbitai plan

[coderabbitai]

Coding Plan

Summary

• Add revokeTokenKyc by mirroring the existing freezeToken endpoint, since both share the tokenId + accountId transaction shape.
• Introduce a param dataclass, a status-only response dataclass, and a registered handler that wraps the already-implemented TokenRevokeKycTransaction SDK class.
• Rely on the existing generic dispatch/registry and transport layers — no wiring changes needed beyond the three token-layer files.

Implementation Steps

Add the revokeTokenKyc TCK endpoint

This phase introduces the request parameters, response shape, and handler needed to expose revokeTokenKyc as a JSON-RPC method. It mirrors the existing freezeToken endpoint (which shares the same tokenId + accountId shape) and reuses the already-implemented SDK TokenRevokeKycTransaction. All three token-layer files follow an established convention, so the work is additive and requires no changes to the dispatch/transport layers.

Task 1: Define request parameters for revokeTokenKyc

Add the param dataclass that parses the incoming JSON-RPC params.

• Add a RevokeKycTokenParams(BaseTransactionParams) dataclass in tck/param/token.py, structurally identical to FreezeTokenParams (fields tokenId: str | None and accountId: str | None).
• Implement its parse_json_params(cls, params) classmethod to pull tokenId/accountId via params.get(...), and populate sessionId and commonTransactionParams using the existing parse_session_id and parse_common_transaction_params helpers.

Task 2: Define the response shape for revokeTokenKyc

Add the status-only response dataclass returned to the caller.

• Add a RevokeKycTokenResponse(StatusOnlyResponse) dataclass in tck/response/token.py, following the one-line pattern used by FreezeTokenResponse/PauseTokenResponse.

Task 3: Implement and register the revokeTokenKyc handler

Add the handler that builds, signs, executes the transaction and returns the receipt status.

• In tck/handlers/token.py, import TokenRevokeKycTransaction from the SDK tokens package.
• Add a private _build_revoke_kyc_token_transaction(params) builder mirroring _build_freeze_token_transaction: instantiate the transaction, set the gRPC deadline, and conditionally set token_id / account_id (converting strings via TokenId.from_string / AccountId.from_string).
• Add a @rpc_method("revokeTokenKyc")-decorated revoke_token_kyc(params: RevokeKycTokenParams) -> RevokeKycTokenResponse handler that gets the client from the session, builds the transaction, applies commonTransactionParams when present, executes with wait_for_receipt=False, fetches the receipt with validate_status=True, and returns the response with ResponseCode(receipt.status).name.
• No changes are needed to tck/handlers/__init__.py, tck/handlers/registry.py, tck/server.py, or tck/protocol.py since the token module is already imported and dispatch is generic.

🤖 Prompt for AI agents

Implement the `revokeTokenKyc` JSON-RPC method in the TCK by mirroring the
existing `freezeToken` endpoint pattern across the param, response, and handler
layers, wrapping the already-implemented SDK `TokenRevokeKycTransaction` class.

1. In `tck/param/token.py`: Add a `RevokeKycTokenParams(BaseTransactionParams)`
dataclass structurally identical to `FreezeTokenParams`, with fields `tokenId:
str | None` and `accountId: str | None`. Implement its `parse_json_params(cls,
params)` classmethod to pull `tokenId`/`accountId` via `params.get(...)`, and
populate `sessionId` and `commonTransactionParams` using the existing
`parse_session_id` and `parse_common_transaction_params` helpers.

2. In `tck/response/token.py`: Add a
`RevokeKycTokenResponse(StatusOnlyResponse)` dataclass, following the one-line
pattern used by `FreezeTokenResponse`/`PauseTokenResponse`.

3. In `tck/handlers/token.py`:
   - Import `TokenRevokeKycTransaction` from the SDK tokens package.
- Add a private `_build_revoke_kyc_token_transaction(params)` builder mirroring
`_build_freeze_token_transaction`: instantiate the transaction, set the gRPC
deadline, and conditionally set `token_id` / `account_id` (converting strings
via `TokenId.from_string` / `AccountId.from_string`).
- Add a `@rpc_method("revokeTokenKyc")`-decorated `revoke_token_kyc(params:
RevokeKycTokenParams) -> RevokeKycTokenResponse` handler that gets the client
from the session, builds the transaction, applies `commonTransactionParams` when
present, executes with `wait_for_receipt=False`, fetches the receipt with
`validate_status=True`, and returns the response with
`ResponseCode(receipt.status).name`.

Do not modify `tck/handlers/__init__.py`, `tck/handlers/registry.py`,
`tck/server.py`, or `tck/protocol.py` since the `token` module is already
imported and dispatch is generic — no wiring changes are needed.

Research

The TCK follows a clean layered architecture — param → handler → response — with a central registry for JSON-RPC dispatch. Request bodies are parsed into @dataclass param classes (tck/param/token.py), handlers (tck/handlers/token.py) build and execute SDK transactions, and results are returned via response dataclasses (tck/response/token.py). The @rpc_method("methodName") decorator in tck/handlers/registry.py registers handlers by their JSON-RPC name; tck/handlers/__init__.py already imports the token module, so no new wiring in the transport layer (server.py/protocol.py) is required. The underlying TokenRevokeKycTransaction SDK class already exists in src/hiero_sdk_python/tokens/token_revoke_kyc_transaction.py with set_token_id/set_account_id setters matching the freezeToken shape, so only the TCK layer needs additions.

File-Level Change Summary

• tck/param/token.py: Add RevokeKycTokenParams dataclass with parse_json_params.
• tck/response/token.py: Add RevokeKycTokenResponse extending StatusOnlyResponse.
• tck/handlers/token.py: Add SDK import, _build_revoke_kyc_token_transaction builder, and @rpc_method("revokeTokenKyc") handler.

Follow-up Notes

• The ticket references grantTokenKyc (Issue 5) as a prerequisite/mirror. If grantTokenKyc is not yet implemented, apply the identical three-file pattern for it as well (or coordinate ordering), since the two are exact mirrors differing only in the SDK class (TokenGrantKycTransaction) and method name.
• Validate against the external Hiero SDK TCK conformance suite referenced in the spec, as per-method behavior is verified there rather than by pytest files in this repo.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Implement the `revokeTokenKyc` JSON-RPC method in the TCK by mirroring the
existing `freezeToken` endpoint pattern across the param, response, and handler
layers, wrapping the already-implemented SDK `TokenRevokeKycTransaction` class.

1. In `tck/param/token.py`: Add a `RevokeKycTokenParams(BaseTransactionParams)`
dataclass structurally identical to `FreezeTokenParams`, with fields `tokenId:
str | None` and `accountId: str | None`. Implement its `parse_json_params(cls,
params)` classmethod to pull `tokenId`/`accountId` via `params.get(...)`, and
populate `sessionId` and `commonTransactionParams` using the existing
`parse_session_id` and `parse_common_transaction_params` helpers.

2. In `tck/response/token.py`: Add a
`RevokeKycTokenResponse(StatusOnlyResponse)` dataclass, following the one-line
pattern used by `FreezeTokenResponse`/`PauseTokenResponse`.

3. In `tck/handlers/token.py`:
   - Import `TokenRevokeKycTransaction` from the SDK tokens package.
- Add a private `_build_revoke_kyc_token_transaction(params)` builder mirroring
`_build_freeze_token_transaction`: instantiate the transaction, set the gRPC
deadline, and conditionally set `token_id` / `account_id` (converting strings
via `TokenId.from_string` / `AccountId.from_string`).
- Add a `@rpc_method("revokeTokenKyc")`-decorated `revoke_token_kyc(params:
RevokeKycTokenParams) -> RevokeKycTokenResponse` handler that gets the client
from the session, builds the transaction, applies `commonTransactionParams` when
present, executes with `wait_for_receipt=False`, fetches the receipt with
`validate_status=True`, and returns the response with
`ResponseCode(receipt.status).name`.

Do not modify `tck/handlers/__init__.py`, `tck/handlers/registry.py`,
`tck/server.py`, or `tck/protocol.py` since the `token` module is already
imported and dispatch is generic — no wiring changes are needed.

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!

[iron-prog]

i would like to work on this

[github-actions]

👋 Hi @iron-prog! If you'd like to work on this issue, please comment /assign to get assigned.

[iron-prog]

/assign

[github-actions]

👋 Hi @iron-prog! Thanks for your interest in contributing 💡

Before taking on a beginner issue, we ask contributors to complete at least one Good First Issue to get familiar with the workflow.

👉 Find a Good First Issue here

Please try a GFI first, then come back — we’ll be happy to assign this! 😊

[exploreriii]

@iron-prog feel free to find a typo or something as a GFI, sorry about this. We have the guards in place as it helps to build up trust and experience