feat(tck): implement createContract JSON-RPC method (#2611)

Signed-off-by: exploreriii <133720349+exploreriii@users.noreply.github.com>

Author: exploreriii

src/hiero_sdk_python/contract/contract_create_transaction.py

@@ -94,6 +94,8 @@ def __init__(self, contract_params: ContractCreateParams | None = None):
         super().__init__()
 
         params = contract_params or ContractCreateParams()
+        if params.gas is not None and params.gas < 0:
+            raise ValueError("Gas cannot be negative")
         self.bytecode_file_id: FileId | None = params.bytecode_file_id
         self.proxy_account_id: AccountId | None = params.proxy_account_id
         self.admin_key: Key | None = params.admin_key
@@ -115,6 +117,9 @@ def set_bytecode_file_id(self, bytecode_file_id: FileId | None) -> ContractCreat
         """
         Sets the FileID of the file containing the contract bytecode.
 
+        The two bytecode sources share the protobuf initcodeSource oneof, so a
+        non-None value clears any inline bytecode.
+
         Args:
             bytecode_file_id (FileId | None): The FileID of the
                 bytecode file.
@@ -124,6 +129,8 @@ def set_bytecode_file_id(self, bytecode_file_id: FileId | None) -> ContractCreat
         """
         self._require_not_frozen()
         self.bytecode_file_id = bytecode_file_id
+        if bytecode_file_id is not None:
+            self.bytecode = None
         return self
 
     def set_bytecode(self, code: bytes | None) -> ContractCreateTransaction:
@@ -133,6 +140,9 @@ def set_bytecode(self, code: bytes | None) -> ContractCreateTransaction:
         If the bytecode is small enough, it may be stored directly in the
         transaction, otherwise it should be stored in a file.
 
+        The two bytecode sources share the protobuf initcodeSource oneof, so a
+        non-None value clears any bytecode file ID.
+
         Args:
             code (bytes | None): The contract bytecode.
 
@@ -141,7 +151,8 @@ def set_bytecode(self, code: bytes | None) -> ContractCreateTransaction:
         """
         self._require_not_frozen()
         self.bytecode = code
-        self.bytecode_file_id = None
+        if code is not None:
+            self.bytecode_file_id = None
         return self
 
     def set_proxy_account_id(self, proxy_account_id: AccountId | None) -> ContractCreateTransaction:
@@ -181,8 +192,13 @@ def set_gas(self, gas: int | None) -> ContractCreateTransaction:
 
         Returns:
             ContractCreateTransaction: This transaction instance.
+
+        Raises:
+            ValueError: If gas is negative.
         """
         self._require_not_frozen()
+        if gas is not None and gas < 0:
+            raise ValueError("Gas cannot be negative")
         self.gas = gas
         return self
 
@@ -284,6 +300,9 @@ def set_staked_account_id(self, staked_account_id: AccountId | None) -> Contract
         """
         Sets the account ID to stake to.
 
+        The two staking targets share the protobuf staked_id oneof, so a
+        non-None value clears any staked node ID.
+
         Args:
             staked_account_id (AccountId | None): The staked account ID.
 
@@ -292,12 +311,17 @@ def set_staked_account_id(self, staked_account_id: AccountId | None) -> Contract
         """
         self._require_not_frozen()
         self.staked_account_id = staked_account_id
+        if staked_account_id is not None:
+            self.staked_node_id = None
         return self
 
     def set_staked_node_id(self, staked_node_id: int | None) -> ContractCreateTransaction:
         """
         Sets the node ID to stake to.
 
+        The two staking targets share the protobuf staked_id oneof, so a
+        non-None value clears any staked account ID.
+
         Args:
             staked_node_id (int | None): The staked node ID.
 
@@ -306,6 +330,8 @@ def set_staked_node_id(self, staked_node_id: int | None) -> ContractCreateTransa
         """
         self._require_not_frozen()
         self.staked_node_id = staked_node_id
+        if staked_node_id is not None:
+            self.staked_account_id = None
         return self
 
     def set_decline_reward(self, decline_reward: bool | None) -> ContractCreateTransaction:
@@ -323,26 +349,25 @@ def set_decline_reward(self, decline_reward: bool | None) -> ContractCreateTrans
         self.decline_reward = decline_reward
         return self
 
-    def _validate_parameters(self):
-        """Validates the parameters for the contract creation transaction."""
-        if self.bytecode_file_id is None and self.bytecode is None:
-            raise ValueError("Either bytecode_file_id or bytecode must be provided")
-
-        if self.gas is None:
-            raise ValueError("Gas limit must be provided")
-
     def _build_proto_body(self):
         """
         Returns the protobuf body for the contract create transaction.
 
+        Missing fields are not validated client-side; the network reports
+        errors such as CONTRACT_BYTECODE_EMPTY or INSUFFICIENT_GAS.
+
         Returns:
             ContractCreateTransactionBody: The protobuf body for this transaction.
 
         Raises:
-            ValueError: If required fields are missing.
-        """
-        self._validate_parameters()
-
+            ValueError: If both staked_account_id and staked_node_id are set,
+                or both bytecode and bytecode_file_id are set; each pair shares
+                a protobuf oneof that would silently drop one of them.
+        """
+        if self.staked_account_id is not None and self.staked_node_id is not None:
+            raise ValueError("Specify either staked_node_id or staked_account_id, not both.")
+        if self.bytecode is not None and self.bytecode_file_id is not None:
+            raise ValueError("Specify either bytecode or bytecode_file_id, not both.")
         return ContractCreateTransactionBody(
             gas=self.gas,
             initialBalance=self.initial_balance,

tck/handlers/__init__.py

@@ -5,6 +5,7 @@
 from . import (
     account,
     allowance,
+    contract,
     file,
     key,
     schedule,

tck/handlers/contract.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from hiero_sdk_python.account.account_id import AccountId
+from hiero_sdk_python.contract.contract_create_transaction import ContractCreateTransaction
+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.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.util.client_utils import get_client
+from tck.util.constants import DEFAULT_GRPC_TIMEOUT
+from tck.util.key_utils import get_key_from_string
+from tck.util.param_utils import decode_hex, to_int
+
+
+INT64_MIN = -(2**63)
+INT64_MAX = 2**63 - 1
+
+
+def _require_int64(value: str, name: str) -> int:
+    """Parse an int64 JSON-RPC param transported as a string.
+
+    Python ints are unbounded, so enforce the wire type's int64 range here
+    (gas, initialBalance, autoRenewPeriod, stakedNodeId); boundary values
+    themselves are valid and left for the network to judge.
+    """
+    parsed = to_int(value)
+    if parsed is None:
+        raise JsonRpcError.invalid_params_error(f"{name} must be an integer")
+    if not INT64_MIN <= parsed <= INT64_MAX:
+        raise JsonRpcError.invalid_params_error(f"{name} must fit in an int64")
+    return parsed
+
+
+def _build_create_contract_transaction(params: CreateContractParams) -> ContractCreateTransaction:
+    """Map createContract JSON-RPC params onto a ContractCreateTransaction.
+
+    Only supplied params are applied, so SDK defaults stay intact.
+    """
+    transaction = ContractCreateTransaction().set_grpc_deadline(DEFAULT_GRPC_TIMEOUT)
+
+    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.gas is not None:
+        transaction.set_gas(_require_int64(params.gas, "gas"))
+
+    if params.autoRenewAccountId is not None:
+        transaction.set_auto_renew_account_id(AccountId.from_string(params.autoRenewAccountId))
+
+    if params.initialBalance is not None:
+        transaction.set_initial_balance(_require_int64(params.initialBalance, "initialBalance"))
+
+    # Order matters: when both bytecode sources are supplied, bytecodeFileId wins
+    # (matches the JS TCK server; the setters clear each other).
+    if params.initcode is not None:
+        transaction.set_bytecode(decode_hex(params.initcode))
+
+    if params.bytecodeFileId is not None:
+        transaction.set_bytecode_file_id(FileId.from_string(params.bytecodeFileId))
+
+    # The SDK's staking-target setters clear each other (the fields share the
+    # protobuf staked_id oneof), so if both are supplied the one applied last
+    # (stakedNodeId) wins, matching the JS TCK server.
+    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)
+
+    if params.memo is not None:
+        transaction.set_contract_memo(params.memo)
+
+    if params.maxAutomaticTokenAssociations is not None:
+        transaction.set_max_automatic_token_associations(params.maxAutomaticTokenAssociations)
+
+    if params.constructorParameters is not None:
+        transaction.set_constructor_parameters(decode_hex(params.constructorParameters))
+
+    return transaction
+
+
+@rpc_method("createContract")
+def create_contract(params: CreateContractParams) -> CreateContractResponse:
+    """Create a smart contract."""
+    client = get_client(params.sessionId)
+
+    transaction = _build_create_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)
+
+    contract_id = ""
+    if receipt.status == ResponseCode.SUCCESS and receipt.contract_id is not None:
+        contract_id = str(receipt.contract_id)
+
+    return CreateContractResponse(contract_id, ResponseCode(receipt.status).name)

tck/param/contract.py

@@ -0,0 +1,47 @@
+"""TCK request parameter models for contract endpoints."""
+
+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
+
+
+@dataclass
+class CreateContractParams(BaseTransactionParams):
+    """Parameters for creating a smart contract. Extends BaseTransactionParams to include common transaction parameters."""
+
+    bytecodeFileId: str | None = None
+    initcode: str | None = None
+    adminKey: str | None = None
+    gas: str | None = None
+    initialBalance: str | None = None
+    constructorParameters: str | None = None
+    autoRenewPeriod: str | None = None
+    autoRenewAccountId: str | None = None
+    memo: str | None = None
+    stakedAccountId: str | None = None
+    stakedNodeId: str | None = None
+    declineStakingReward: bool | None = None
+    maxAutomaticTokenAssociations: int | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> CreateContractParams:
+        return cls(
+            bytecodeFileId=params.get("bytecodeFileId"),
+            initcode=params.get("initcode"),
+            adminKey=params.get("adminKey"),
+            gas=params.get("gas"),
+            initialBalance=params.get("initialBalance"),
+            constructorParameters=params.get("constructorParameters"),
+            autoRenewPeriod=params.get("autoRenewPeriod"),
+            autoRenewAccountId=params.get("autoRenewAccountId"),
+            memo=params.get("memo"),
+            stakedAccountId=params.get("stakedAccountId"),
+            stakedNodeId=params.get("stakedNodeId"),
+            declineStakingReward=params.get("declineStakingReward"),
+            maxAutomaticTokenAssociations=params.get("maxAutomaticTokenAssociations"),
+            sessionId=parse_session_id(params),
+            commonTransactionParams=parse_common_transaction_params(params),
+        )

tck/response/contract.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class CreateContractResponse:
+    """Response payload for createContract."""
+
+    contractId: str | None = None
+    status: str | None = None

tck/util/param_utils.py

@@ -1,5 +1,10 @@
 from __future__ import annotations
 
+import re
+
+
+_HEX_DIGITS_RE = re.compile(r"[0-9a-fA-F]*")
+
 
 def parse_session_id(params: dict) -> str:
     """Parse sessionId from the json rpc params."""
@@ -52,6 +57,20 @@ def non_empty_string_list(values) -> list[str] | None:
     return cleaned_values
 
 
+def decode_hex(value: str) -> bytes:
+    """Decode a hex string (optionally 0x-prefixed) into bytes.
+
+    Raises ValueError on odd-length, whitespace-containing, or otherwise
+    non-hexadecimal input, matching the behaviour of the other SDKs' TCK
+    servers. bytes.fromhex alone is too lenient: it ignores embedded ASCII
+    whitespace.
+    """
+    text = value[2:] if value.startswith("0x") else value
+    if not _HEX_DIGITS_RE.fullmatch(text):
+        raise ValueError(f"non-hexadecimal characters in hex string: {value!r}")
+    return bytes.fromhex(text)
+
+
 def to_bool(value) -> bool | None:
     """Helper to convert value to bool."""
     if isinstance(value, str):

tests/tck/contract_handler_test.py

@@ -0,0 +1,44 @@
+"""Test cases for the TCK createContract handler."""
+
+from __future__ import annotations
+
+import pytest
+
+from tck.errors import INVALID_PARAMS, JsonRpcError
+from tck.handlers import contract as contract_handlers
+from tck.param.contract import CreateContractParams
+
+
+pytestmark = pytest.mark.unit
+
+
+class TestBuildCreateContractTransaction:
+    def test_bytecode_file_id_wins_when_both_sources_supplied(self):
+        params = CreateContractParams(
+            sessionId="session-1",
+            initcode="0x60006000",
+            bytecodeFileId="0.0.123",
+            gas="1000000",
+        )
+
+        transaction = contract_handlers._build_create_contract_transaction(params)
+
+        assert str(transaction.bytecode_file_id) == "0.0.123"
+        assert transaction.bytecode is None
+
+    def test_invalid_gas_raises_invalid_params(self):
+        params = CreateContractParams(sessionId="session-1", gas="not-a-number")
+
+        with pytest.raises(JsonRpcError) as excinfo:
+            contract_handlers._build_create_contract_transaction(params)
+
+        assert excinfo.value.code == INVALID_PARAMS
+
+    @pytest.mark.parametrize("gas", ["9223372036854775808", "-9223372036854775809"])
+    def test_gas_out_of_int64_range_raises_invalid_params(self, gas):
+        params = CreateContractParams(sessionId="session-1", gas=gas)
+
+        with pytest.raises(JsonRpcError) as excinfo:
+            contract_handlers._build_create_contract_transaction(params)
+
+        assert excinfo.value.code == INVALID_PARAMS