feat (tck): add updateAccount endpoint with request and response models (hiero-ledger#2320)

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

Author: danielmarv

src/hiero_sdk_python/account/account_update_transaction.py

@@ -284,15 +284,9 @@ def _build_proto_body(self):
 
         Returns:
             CryptoUpdateTransactionBody: The protobuf body for this transaction.
-
-        Raises:
-            ValueError: If account_id is not set.
         """
-        if self.account_id is None:
-            raise ValueError("Missing required AccountID to update")
-
         proto_body = CryptoUpdateTransactionBody(
-            accountIDToUpdate=self.account_id._to_proto(),
+            accountIDToUpdate=self.account_id._to_proto() if self.account_id else None,
             key=self.key.to_proto_key() if self.key else None,
             memo=StringValue(value=self.account_memo) if self.account_memo is not None else None,
             autoRenewPeriod=(self.auto_renew_period._to_proto() if self.auto_renew_period else None),

tck/handlers/account.py

@@ -5,17 +5,21 @@
 from hiero_sdk_python.account.account_create_transaction import AccountCreateTransaction
 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
+from hiero_sdk_python.Duration import Duration
 from hiero_sdk_python.hbar import Hbar
 from hiero_sdk_python.query.account_info_query import AccountInfoQuery
 from hiero_sdk_python.response_code import ResponseCode
+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
+from tck.param.account import CreateAccountParams, GetAccountInfoParams, UpdateAccountParams
 from tck.response.account import (
     CreateAccountResponse,
     GetAccountInfoResponse,
     StakingInfoResponse,
     TokenRelationshipResponse,
+    UpdateAccountResponse,
 )
 from tck.util.client_utils import get_client
 from tck.util.constants import DEFAULT_GRPC_TIMEOUT
@@ -78,6 +82,59 @@ def create_account(params: CreateAccountParams) -> CreateAccountResponse:
     return CreateAccountResponse(account_id, ResponseCode(receipt.status).name)
 
 
+def _build_update_account_transaction(params: UpdateAccountParams) -> AccountUpdateTransaction:
+    transaction = AccountUpdateTransaction().set_grpc_deadline(DEFAULT_GRPC_TIMEOUT)
+    transaction.set_auto_renew_period(None)
+
+    if params.accountId is not None:
+        transaction.set_account_id(AccountId.from_string(params.accountId))
+
+    if params.key is not None:
+        transaction.set_key(get_key_from_string(params.key))
+
+    if params.expirationTime is not None:
+        transaction.set_expiration_time(Timestamp(params.expirationTime, 0))
+
+    if params.receiverSignatureRequired is not None:
+        transaction.set_receiver_signature_required(params.receiverSignatureRequired)
+
+    if params.maxAutoTokenAssociations is not None:
+        transaction.set_max_automatic_token_associations(params.maxAutoTokenAssociations)
+
+    if params.stakedAccountId is not None:
+        transaction.set_staked_account_id(AccountId.from_string(params.stakedAccountId))
+
+    if params.stakedNodeId is not None:
+        transaction.set_staked_node_id(params.stakedNodeId)
+
+    if params.declineStakingReward is not None:
+        transaction.set_decline_staking_reward(params.declineStakingReward)
+
+    if params.memo is not None:
+        transaction.set_account_memo(params.memo)
+
+    if params.autoRenewPeriod is not None:
+        transaction.set_auto_renew_period(Duration(params.autoRenewPeriod))
+
+    return transaction
+
+
+@rpc_method("updateAccount")
+def update_account(params: UpdateAccountParams) -> UpdateAccountResponse:
+    """Update an account using TCK updateAccount parameters."""
+    client = get_client(params.sessionId)
+
+    transaction = _build_update_account_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 UpdateAccountResponse(ResponseCode(receipt.status).name)
+
+
 def _enum_name(value) -> str | None:
     if value is None:
         return None

tck/param/account.py

@@ -47,6 +47,44 @@ def parse_json_params(cls, params: dict) -> CreateAccountParams:
         )
 
 
+@dataclass
+class UpdateAccountParams(BaseTransactionParams):
+    """Request parameters for the updateAccount endpoint."""
+
+    accountId: str | None = None
+    key: str | None = None
+    receiverSignatureRequired: bool | None = None
+    autoRenewPeriod: int | None = None
+    expirationTime: int | None = None
+    memo: str | None = None
+    maxAutoTokenAssociations: int | None = None
+    stakedAccountId: str | None = None
+    stakedNodeId: int | None = None
+    declineStakingReward: bool | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> UpdateAccountParams:
+        """Parse JSON-RPC params into an UpdateAccountParams instance."""
+        decline_staking_reward = params.get("declineStakingReward")
+        if decline_staking_reward is None:
+            decline_staking_reward = params.get("declineStakingRewards")
+
+        return cls(
+            accountId=params.get("accountId"),
+            key=params.get("key"),
+            receiverSignatureRequired=to_bool(params.get("receiverSignatureRequired")),
+            autoRenewPeriod=to_int(params.get("autoRenewPeriod")),
+            expirationTime=to_int(params.get("expirationTime")),
+            memo=params.get("memo"),
+            maxAutoTokenAssociations=to_int(params.get("maxAutoTokenAssociations")),
+            stakedAccountId=params.get("stakedAccountId"),
+            stakedNodeId=to_int(params.get("stakedNodeId")),
+            declineStakingReward=to_bool(decline_staking_reward),
+            sessionId=parse_session_id(params),
+            commonTransactionParams=parse_common_transaction_params(params),
+        )
+
+
 @dataclass
 class GetAccountInfoParams(BaseParams):
     """Request parameters for the getAccountInfo endpoint."""

tck/response/account.py

@@ -13,6 +13,13 @@ class CreateAccountResponse:
     status: str | None = None
 
 
+@dataclass
+class UpdateAccountResponse:
+    """Response payload for updateAccount."""
+
+    status: str | None = None
+
+
 @dataclass
 class StakingInfoResponse:
     """Nested staking fields in the getAccountInfo response."""

tests/unit/account_update_transaction_test.py

@@ -332,11 +332,11 @@ def test_build_transaction_body_receiver_sig_required_variants(mock_account_ids)
 
 
 def test_missing_account_id():
-    """Test that building a transaction without setting account_id raises a ValueError."""
+    """Test that building a transaction without setting account_id omits the field from proto."""
     account_tx = AccountUpdateTransaction()
 
-    with pytest.raises(ValueError, match="Missing required AccountID to update"):
-        account_tx.build_transaction_body()
+    proto_body = account_tx._build_proto_body()
+    assert not proto_body.HasField("accountIDToUpdate")
 
 
 def test_sign_transaction(mock_client):