feat(tck): implement updateContract JSON-RPC method

Signed-off-by: achintya2k5 <achintyasin@gmail.com>

Author: achintya2k5

src/hiero_sdk_python/contract/contract_update_transaction.py

@@ -14,7 +14,7 @@
 from hiero_sdk_python.crypto.key import Key
 from hiero_sdk_python.Duration import Duration
 from hiero_sdk_python.executable import _Method
-from hiero_sdk_python.hapi.services import contract_update_pb2, transaction_pb2
+from hiero_sdk_python.hapi.services import basic_types_pb2, contract_update_pb2, transaction_pb2
 from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import (
     SchedulableTransactionBody,
 )
@@ -190,6 +190,8 @@ def set_auto_renew_account_id(self, auto_renew_account_id: AccountId | None) ->
         """
         Sets the new account ID that will be charged for the contract's auto-renewal.
 
+        Passing an AccountId of `0.0.0` clears the auto-renew account configuration.
+
         Args:
             auto_renew_account_id (AccountId | None): The new account ID that will be
                 charged for the contract's auto-renewal.
@@ -213,6 +215,7 @@ def set_staked_node_id(self, staked_node_id: int | None) -> ContractUpdateTransa
         """
         self._require_not_frozen()
         self.staked_node_id = staked_node_id
+        self.staked_account_id = None
         return self
 
     def set_decline_reward(self, decline_reward: bool | None) -> ContractUpdateTransaction:
@@ -233,6 +236,10 @@ def set_staked_account_id(self, staked_account_id: AccountId | None) -> Contract
         """
         Sets the new account ID to which the contract stakes.
 
+        This field is mutually exclusive with staked_node_id. Setting this will
+        clear any previously set staked_node_id. Passing an AccountId of
+        `0.0.0` removes staking and sends the sentinel AccountId (0.0.0) to the network.
+
         Args:
             staked_account_id (AccountId | None): The new account ID to which the contract
                 stakes.
@@ -242,27 +249,18 @@ def set_staked_account_id(self, staked_account_id: AccountId | None) -> Contract
         """
         self._require_not_frozen()
         self.staked_account_id = staked_account_id
+        self.staked_node_id = None
         return self
 
     def _convert_to_proto(self, obj: Any | None) -> Any:
-        """Convert object to proto if it exists, otherwise return None."""
-        return obj._to_proto() if obj else None
+        """Convert object to proto if it is not None, otherwise return None."""
+        return obj._to_proto() if obj is not None else None
 
     def _build_proto_body(self):
         """
         Returns the protobuf body for the contract update transaction.
-
-        Returns:
-            ContractUpdateTransactionBody: The protobuf body for this transaction.
-
-        Raises:
-            ValueError: If contract_id is not set.
         """
-        if self.contract_id is None:
-            raise ValueError("Missing required ContractID")
-
-        return contract_update_pb2.ContractUpdateTransactionBody(
-            contractID=self.contract_id._to_proto(),
+        body = contract_update_pb2.ContractUpdateTransactionBody(
             expirationTime=(self.expiration_time._to_protobuf() if self.expiration_time else None),
             adminKey=self.admin_key.to_proto_key() if self.admin_key else None,
             autoRenewPeriod=self._convert_to_proto(self.auto_renew_period),
@@ -273,11 +271,23 @@ def _build_proto_body(self):
                 if self.max_automatic_token_associations is not None
                 else None
             ),
-            staked_account_id=self._convert_to_proto(self.staked_account_id),
-            auto_renew_account_id=self._convert_to_proto(self.auto_renew_account_id),
             decline_reward=(BoolValue(value=self.decline_reward) if self.decline_reward is not None else None),
         )
 
+        if self.contract_id is not None:
+            body.contractID.CopyFrom(self.contract_id._to_proto())
+
+        if self.auto_renew_account_id is not None:
+            if self.auto_renew_account_id == AccountId.from_string("0.0.0"):
+                body.auto_renew_account_id.CopyFrom(basic_types_pb2.AccountID())
+            else:
+                body.auto_renew_account_id.CopyFrom(self.auto_renew_account_id._to_proto())
+
+        if self.staked_account_id is not None:
+            body.staked_account_id.CopyFrom(self.staked_account_id._to_proto())
+
+        return body
+
     def build_transaction_body(self) -> transaction_pb2.TransactionBody:
         """
         Builds and returns the protobuf transaction body for contract update.

tck/handlers/contract.py

@@ -2,13 +2,17 @@
 
 from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.contract.contract_create_transaction import ContractCreateTransaction
+from hiero_sdk_python.contract.contract_id import ContractId
+from hiero_sdk_python.contract.contract_update_transaction import ContractUpdateTransaction
 from hiero_sdk_python.Duration import Duration
 from hiero_sdk_python.file.file_id import FileId
 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.errors import JsonRpcError
 from tck.handlers.registry import rpc_method
-from tck.param.contract import CreateContractParams
-from tck.response.contract import CreateContractResponse
+from tck.param.contract import CreateContractParams, UpdateContractParams
+from tck.response.contract import CreateContractResponse, UpdateContractResponse
 from tck.util.client_utils import get_client
 from tck.util.constants import DEFAULT_GRPC_TIMEOUT
 from tck.util.key_utils import get_key_from_string
@@ -89,6 +93,48 @@ def _build_create_contract_transaction(params: CreateContractParams) -> Contract
     return transaction
 
 
+def _build_update_contract_transaction(params: UpdateContractParams) -> ContractUpdateTransaction:
+    """
+    Maps updateContract JSON-RPC params onto a ContractUpdateTransaction.
+
+    Only supplied params are applied, SDK defaults remain intact.
+    """
+
+    transaction = ContractUpdateTransaction().set_grpc_deadline(DEFAULT_GRPC_TIMEOUT)
+
+    if params.contractId is not None:
+        transaction.set_contract_id(ContractId.from_string(params.contractId))
+
+    if params.adminKey is not None:
+        transaction.set_admin_key(get_key_from_string(params.adminKey))
+
+    if params.autoRenewPeriod is not None:
+        transaction.set_auto_renew_period(Duration(_require_int64(params.autoRenewPeriod, "autoRenewPeriod")))
+
+    if params.expirationTime is not None:
+        transaction.set_expiration_time(Timestamp(seconds=to_int(params.expirationTime), nanos=0))
+
+    if params.memo is not None:
+        transaction.set_contract_memo(params.memo)
+
+    if params.autoRenewAccountId is not None:
+        transaction.set_auto_renew_account_id(AccountId.from_string(params.autoRenewAccountId))
+
+    if params.maxAutomaticTokenAssociations is not None:
+        transaction.set_max_automatic_token_associations(params.maxAutomaticTokenAssociations)
+
+    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(_require_int64(params.stakedNodeId, "stakedNodeId"))
+
+    if params.declineStakingReward is not None:
+        transaction.set_decline_reward(params.declineStakingReward)
+
+    return transaction
+
+
 @rpc_method("createContract")
 def create_contract(params: CreateContractParams) -> CreateContractResponse:
     """Create a smart contract."""
@@ -106,3 +152,19 @@ def create_contract(params: CreateContractParams) -> CreateContractResponse:
         contract_id = str(receipt.contract_id)
 
     return CreateContractResponse(contract_id, ResponseCode(receipt.status).name)
+
+
+@rpc_method("updateContract")
+def update_contract(params: UpdateContractParams) -> UpdateContractResponse:
+    """Update a smart contract."""
+    client = get_client(params.sessionId)
+
+    transaction = _build_update_contract_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 UpdateContractResponse(status=ResponseCode(receipt.status).name)

tck/param/contract.py

@@ -45,3 +45,36 @@ def parse_json_params(cls, params: dict) -> CreateContractParams:
             sessionId=parse_session_id(params),
             commonTransactionParams=parse_common_transaction_params(params),
         )
+
+
+@dataclass
+class UpdateContractParams(BaseTransactionParams):
+    """Parameters for updating a smart contract. Extends BaseTransactionParams to include CommonTransactionParams."""
+
+    contractId: str | None = None
+    adminKey: str | None = None
+    autoRenewPeriod: str | None = None
+    expirationTime: str | None = None
+    memo: str | None = None
+    autoRenewAccountId: str | None = None
+    maxAutomaticTokenAssociations: int | None = None
+    stakedAccountId: str | None = None
+    stakedNodeId: str | None = None
+    declineStakingReward: bool | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> UpdateContractParams:
+        return cls(
+            contractId=params.get("contractId"),
+            adminKey=params.get("adminKey"),
+            autoRenewPeriod=params.get("autoRenewPeriod"),
+            expirationTime=params.get("expirationTime"),
+            memo=params.get("memo"),
+            autoRenewAccountId=params.get("autoRenewAccountId"),
+            maxAutomaticTokenAssociations=params.get("maxAutomaticTokenAssociations"),
+            stakedAccountId=params.get("stakedAccountId"),
+            stakedNodeId=params.get("stakedNodeId"),
+            declineStakingReward=params.get("declineStakingReward"),
+            sessionId=parse_session_id(params),
+            commonTransactionParams=parse_common_transaction_params(params),
+        )

tck/response/contract.py

@@ -2,10 +2,17 @@
 
 from dataclasses import dataclass
 
+from tck.response.base import StatusOnlyResponse
+
 
 @dataclass
 class CreateContractResponse:
     """Response payload for createContract."""
 
     contractId: str | None = None
     status: str | None = None
+
+
+@dataclass
+class UpdateContractResponse(StatusOnlyResponse):
+    """Response payload for updateContract."""

tests/unit/contract_update_transaction_test.py

@@ -162,6 +162,34 @@ def test_set_decline_reward():
     assert result is tx  # Method chaining
 
 
+def test_set_auto_renew_account_id_to_zero():
+    """Test setting auto renew account ID to 0.0.0 triggers clear flag."""
+    tx = ContractUpdateTransaction()
+    tx.set_auto_renew_account_id(AccountId(0, 0, 0))
+
+    assert tx.auto_renew_account_id == AccountId(0, 0, 0)
+
+
+def test_set_staked_account_id():
+    """Test setting a valid staked account ID."""
+    tx = ContractUpdateTransaction()
+    staked_account_id = AccountId(0, 0, 999)
+    result = tx.set_staked_account_id(staked_account_id)
+
+    assert tx.staked_account_id == staked_account_id
+    assert tx.staked_node_id is None
+    assert result is tx  # Method chaining
+
+
+def test_set_staked_account_id_to_zero():
+    """Test setting staked account ID to 0.0.0 clears staking."""
+    tx = ContractUpdateTransaction()
+    tx.set_staked_account_id(AccountId(0, 0, 0))
+
+    assert tx.staked_account_id == AccountId(0, 0, 0)
+    assert tx.staked_node_id is None
+
+
 ########### Method Chaining Tests ###########
 
 
@@ -227,13 +255,18 @@ def test_build_proto_body_with_generic_admin_key(contract_id, admin_key):
     assert proto_body.adminKey == admin_key.to_proto_key()
 
 
-def test_build_transaction_body_missing_contract_id():
-    """Test building transaction body without contract ID raises ValueError."""
+def test_build_transaction_body_missing_contract_id(mock_account_ids, transaction_id):
+    """Test building transaction body without contract ID omits the field."""
+    _, _, node_account_id, _, _ = mock_account_ids
+
     tx = ContractUpdateTransaction()
     tx.set_contract_memo("Test memo")
+    tx.transaction_id = transaction_id
+    tx.set_node_account_ids([node_account_id])
 
-    with pytest.raises(ValueError, match="Missing required ContractID"):
-        tx.build_transaction_body()
+    transaction_body = tx.build_transaction_body()
+
+    assert not transaction_body.contractUpdateInstance.HasField("contractID")
 
 
 def test_build_transaction_body_with_all_parameters(update_params, mock_account_ids, transaction_id):
@@ -299,6 +332,24 @@ def test_build_scheduled_body_with_all_parameters(update_params, mock_account_id
     assert schedulable_body.contractUpdateInstance.contractID.realmNum == update_params["contract_id"].realm
 
 
+def test_build_proto_body_with_cleared_fields(contract_id):
+    """Test building a contract update body with cleared auto-renew and staked accounts."""
+    tx = ContractUpdateTransaction()
+    tx.set_contract_id(contract_id)
+    tx.set_auto_renew_account_id(AccountId(0, 0, 0))
+    tx.set_staked_account_id(AccountId(0, 0, 0))
+
+    proto_body = tx._build_proto_body()
+
+    # Check auto-renew account handles the explicit empty message
+    assert proto_body.HasField("auto_renew_account_id")
+    assert proto_body.auto_renew_account_id.accountNum == 0
+
+    # Check staked account ID natively serializes the 0.0.0 sentinel
+    assert proto_body.HasField("staked_account_id")
+    assert proto_body.staked_account_id.accountNum == 0
+
+
 ########### Transaction Execution Tests ###########