Enable deploying contracts without providing abi

starknet_py/contract.py

@@ -961,7 +961,7 @@ async def deploy_contract_v1(
     async def deploy_contract_v3(
         account: BaseAccount,
         class_hash: Hash,
-        abi: List,
+        abi: Optional[List] = None,
         constructor_args: Optional[Union[List, Dict]] = None,
         *,
         deployer_address: AddressRepresentation = DEFAULT_DEPLOYER_ADDRESS,
@@ -1012,9 +1012,15 @@ async def deploy_contract_v3(
             auto_estimate=auto_estimate,
         )
 
-        deployed_contract = Contract(
-            provider=account, address=address, abi=abi, cairo_version=cairo_version
-        )
+        if abi is not None:
+            deployed_contract = Contract(
+                provider=account, address=address, abi=abi, cairo_version=cairo_version
+            )
+        else:
+            deployed_contract = await Contract.from_address(
+                address=address, provider=account
+            )
+
         deploy_result = DeployResult(
             hash=res.transaction_hash,
             _client=account.client,

starknet_py/net/udc_deployer/deployer.py

@@ -75,12 +75,19 @@ def create_contract_deployment(
         :param calldata: Constructor args of the contract to be deployed.
         :return: NamedTuple with call and address of the contract to be deployed.
         """
-        if not abi and calldata:
-            raise ValueError("Argument calldata was provided without an ABI.")
+        raw_calldata = None
 
-        raw_calldata = translate_constructor_args(
-            abi=abi or [], constructor_args=calldata, cairo_version=cairo_version
-        )
+        if calldata and abi is None:
+            if not _is_list_of_ints_or_strings(calldata):
+                raise ValueError(
+                    "Argument calldata was provided without an ABI. It cannot be serialized."
+                )
+            raw_calldata = [int_from_hex(x) for x in calldata]
+
+        elif calldata and abi:
+            raw_calldata = translate_constructor_args(
+                abi=abi or [], constructor_args=calldata, cairo_version=cairo_version
+            )
 
         return self.create_contract_deployment_raw(
             class_hash=class_hash, salt=salt, raw_calldata=raw_calldata
@@ -176,3 +183,15 @@ def _get_random_salt() -> int:
 _deployer_serializer = serializer_for_function(
     _deployer_abi.functions["deployContract"]
 )
+
+
+def _is_list_of_ints_or_strings(data: Union[List, dict]) -> bool:
+    """
+    Checks if the given data is a list containing only strings or integers.
+
+    :param data: Constructor args (calldata) of the contract to be deployed.
+    :return: True if the data is a list of strings or integers, False otherwise.
+    """
+    if isinstance(data, list):
+        return all(isinstance(x, (int, str)) for x in data)
+    return False

starknet_py/tests/e2e/account/account_test.py

@@ -673,23 +673,6 @@ async def test_sign_invoke_v3_for_fee_estimation(account, map_contract):
     assert estimation.overall_fee > 0
 
 
-# TODO (#1419): Fix contract redeclaration
-@pytest.mark.skip(reason="Redeclaration occurred")
-@pytest.mark.asyncio
-async def test_sign_declare_v1_for_fee_estimation(account, map_compiled_contract):
-    transaction = await account.sign_declare_v1(
-        compiled_contract=map_compiled_contract, max_fee=MAX_FEE
-    )
-
-    estimate_fee_transaction = await account.sign_for_fee_estimate(transaction)
-    assert estimate_fee_transaction.version == transaction.version + 2**128
-
-    estimation = await account.client.estimate_fee(estimate_fee_transaction)
-    assert isinstance(estimation, EstimatedFee)
-    assert estimation.unit == PriceUnit.WEI
-    assert estimation.overall_fee > 0
-
-
 @pytest.mark.asyncio
 async def test_sign_deploy_account_v1_for_fee_estimation(
     client, deploy_account_details_factory

starknet_py/tests/e2e/deploy/deployer_test.py

@@ -26,31 +26,42 @@ async def test_default_deploy_with_class_hash(account, map_class_hash):
     assert contract_deployment.address != 0
 
 
-@pytest.mark.asyncio
-async def test_throws_when_calldata_provided_without_abi(map_class_hash):
-    deployer = Deployer()
-
-    with pytest.raises(ValueError, match="calldata was provided without an ABI."):
-        deployer.create_contract_deployment(
-            class_hash=map_class_hash, calldata=[12, 34]
-        )
-
-
 @pytest.mark.skipif(
     "--contract_dir=v2" not in sys.argv,
     reason="Contract exists only in v2 directory",
 )
 @pytest.mark.asyncio
-async def test_throws_when_calldata_not_provided(constructor_with_arguments_abi):
-    deployer = Deployer()
+@pytest.mark.parametrize("calldata", [[10, 1, 2, 3, 3, 1, 2, 3, 12, 99]])
+async def test_constructor_arguments_contract_deploy_without_abi(
+    account,
+    constructor_with_arguments_class_hash,
+    calldata,
+):
+    deployer = Deployer(account_address=account.address)
 
-    with pytest.raises(
-        ValueError,
-        match="Provided contract has a constructor and no arguments were provided.",
-    ):
-        deployer.create_contract_deployment(
-            class_hash=1234, abi=constructor_with_arguments_abi, cairo_version=1
-        )
+    deploy_call, contract_address = deployer.create_contract_deployment(
+        class_hash=constructor_with_arguments_class_hash,
+        calldata=calldata,
+        cairo_version=1,
+    )
+
+    deploy_invoke_transaction = await account.sign_invoke_v1(
+        deploy_call, max_fee=MAX_FEE
+    )
+    resp = await account.client.send_transaction(deploy_invoke_transaction)
+    await account.client.wait_for_tx(resp.transaction_hash)
+
+    contract = await Contract.from_address(address=contract_address, provider=account)
+
+    result = (await contract.functions["get"].call(block_number="latest"))[0]
+    unwrapped_result = (result[0], result[1], result[2], dict(result[3]))
+    expected_result = (
+        10,
+        (1, (2, 3)),
+        sum([1, 2, 3]),
+        {"value": 12, "nested_struct": {"value": 99}},
+    )
+    assert unwrapped_result == expected_result
 
 
 @pytest.mark.skipif(
@@ -108,6 +119,39 @@ async def test_constructor_arguments_contract_deploy(
     )
 
 
+@pytest.mark.skipif(
+    "--contract_dir=v1" in sys.argv,
+    reason="Contract exists only in v2 directory",
+)
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "calldata",
+    [
+        [10, (1, (2, 3)), [1, 2, 3], {"value": 12, "nested_struct": {"value": 99}}],
+        {
+            "single_value": 10,
+            "tuple": (1, (2, 3)),
+            "arr": [1, 2, 3],
+            "dict": {"value": 12, "nested_struct": {"value": 99}},
+        },
+    ],
+)
+async def test_throws_when_calldata_provided_without_abi(
+    account,
+    constructor_with_arguments_class_hash,
+    calldata,
+):
+    deployer = Deployer(account_address=account.address)
+
+    with pytest.raises(
+        ValueError,
+        match="Argument calldata was provided without an ABI. It cannot be serialized.",
+    ):
+        deployer.create_contract_deployment(
+            class_hash=constructor_with_arguments_class_hash, calldata=calldata
+        )
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     "salt, pass_account_address", [(1, True), (2, False), (None, True), (None, False)]

starknet_py/tests/e2e/docs/code_examples/test_contract.py

@@ -165,3 +165,29 @@ async def test_deploy_contract_v3(account, cairo1_hello_starknet_class_hash: int
         contract_address=contract.address
     )
     assert class_hash == cairo1_hello_starknet_class_hash
+
+
+@pytest.mark.asyncio
+async def test_deploy_contract_v3_without_abi(
+    account, cairo1_hello_starknet_class_hash: int
+):
+    deploy_result = await Contract.deploy_contract_v3(
+        class_hash=cairo1_hello_starknet_class_hash,
+        account=account,
+        l1_resource_bounds=ResourceBounds(
+            max_amount=int(1e5), max_price_per_unit=int(1e13)
+        ),
+    )
+    await deploy_result.wait_for_acceptance()
+
+    contract = deploy_result.deployed_contract
+    assert isinstance(contract.address, int)
+    assert len(contract.functions) == 2
+
+    transaction = await account.client.get_transaction(tx_hash=deploy_result.hash)
+    assert isinstance(transaction, InvokeTransactionV3)
+
+    class_hash = await account.client.get_class_hash_at(
+        contract_address=contract.address
+    )
+    assert class_hash == cairo1_hello_starknet_class_hash