Add cairo 0 declaration methods (#1486)

* Revert "Remove `sign_declare_v1` and `declare_v1` methods (#1451)"

This reverts commit d8b2436.

 Conflicts:
	starknet_py/tests/e2e/fixtures/contracts.py

 Changes to be committed:
	modified:   starknet_py/contract.py
	modified:   starknet_py/net/account/account.py
	modified:   starknet_py/net/account/base_account.py
	modified:   starknet_py/net/client_models.py
	modified:   starknet_py/net/models/__init__.py
	modified:   starknet_py/net/models/transaction.py
	modified:   starknet_py/net/schemas/rpc/transactions.py

* Add proper docstring

Author: kkawula

starknet_py/contract.py

@@ -810,6 +810,43 @@ async def from_address(
             cairo_version=cairo_version,
         )
 
+    # pylint: disable=line-too-long
+    @staticmethod
+    async def declare_v1(
+        account: BaseAccount,
+        compiled_contract: str,
+        *,
+        nonce: Optional[int] = None,
+        max_fee: Optional[int] = None,
+        auto_estimate: bool = False,
+    ) -> DeclareResult:
+        """
+        Declares a contract.
+        This method is deprecated, not covered by tests and will be removed in the future.
+        Please use current version of transaction signing methods.
+
+        Based on https://docs.starknet.io/architecture-and-concepts/network-architecture/transactions/#transaction_versioning
+
+        :param account: BaseAccount used to sign and send declare transaction.
+        :param compiled_contract: String containing compiled contract.
+        :param nonce: Nonce of the transaction.
+        :param max_fee: Max amount of Wei to be paid when executing transaction.
+        :param auto_estimate: Use automatic fee estimation (not recommended, as it may lead to high costs).
+        :return: DeclareResult instance.
+        """
+
+        declare_tx = await account.sign_declare_v1(
+            compiled_contract=compiled_contract,
+            nonce=nonce,
+            max_fee=max_fee,
+            auto_estimate=auto_estimate,
+        )
+
+        return await _declare_contract(
+            declare_tx, account, compiled_contract, cairo_version=0
+        )
+
+    # pylint: enable=line-too-long
     @staticmethod
     async def declare_v2(
         account: BaseAccount,

starknet_py/net/account/account.py

@@ -1,8 +1,9 @@
 import dataclasses
+import json
 from collections import OrderedDict
 from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
 
-from starknet_py.common import create_sierra_compiled_contract
+from starknet_py.common import create_compiled_contract, create_sierra_compiled_contract
 from starknet_py.constants import FEE_CONTRACT_ADDRESS, QUERY_VERSION_BASE
 from starknet_py.hash.address import compute_address
 from starknet_py.hash.selector import get_selector_from_name
@@ -26,6 +27,7 @@
 from starknet_py.net.models.chains import RECOGNIZED_CHAIN_IDS, Chain, parse_chain
 from starknet_py.net.models.transaction import (
     AccountTransaction,
+    DeclareV1,
     DeclareV2,
     DeclareV3,
     DeployAccountV1,
@@ -359,6 +361,40 @@ async def sign_invoke_v3(
         signature = self.signer.sign_transaction(invoke_tx)
         return _add_signature_to_transaction(invoke_tx, signature)
 
+    # pylint: disable=line-too-long
+    async def sign_declare_v1(
+        self,
+        compiled_contract: str,
+        *,
+        nonce: Optional[int] = None,
+        max_fee: Optional[int] = None,
+        auto_estimate: bool = False,
+    ) -> DeclareV1:
+        """
+        This method is deprecated, not covered by tests and will be removed in the future.
+        Please use current version of transaction signing methods.
+
+        Based on https://docs.starknet.io/architecture-and-concepts/network-architecture/transactions/#transaction_versioning
+
+        """
+        if _is_sierra_contract(json.loads(compiled_contract)):
+            raise ValueError(
+                "Signing sierra contracts requires using `sign_declare_v2` method."
+            )
+
+        declare_tx = await self._make_declare_v1_transaction(
+            compiled_contract, nonce=nonce
+        )
+
+        max_fee = await self._get_max_fee(
+            transaction=declare_tx, max_fee=max_fee, auto_estimate=auto_estimate
+        )
+        declare_tx = _add_max_fee_to_transaction(declare_tx, max_fee)
+        signature = self.signer.sign_transaction(declare_tx)
+        return _add_signature_to_transaction(declare_tx, signature)
+
+    # pylint: enable=line-too-long
+
     async def sign_declare_v2(
         self,
         compiled_contract: str,
@@ -400,6 +436,24 @@ async def sign_declare_v3(
         signature = self.signer.sign_transaction(declare_tx)
         return _add_signature_to_transaction(declare_tx, signature)
 
+    async def _make_declare_v1_transaction(
+        self, compiled_contract: str, *, nonce: Optional[int] = None
+    ) -> DeclareV1:
+        contract_class = create_compiled_contract(compiled_contract=compiled_contract)
+
+        if nonce is None:
+            nonce = await self.get_nonce()
+
+        declare_tx = DeclareV1(
+            contract_class=contract_class.convert_to_deprecated_contract_class(),
+            sender_address=self.address,
+            max_fee=0,
+            signature=[],
+            nonce=nonce,
+            version=1,
+        )
+        return declare_tx
+
     async def _make_declare_v2_transaction(
         self,
         compiled_contract: str,

starknet_py/net/account/base_account.py

@@ -13,6 +13,7 @@
 from starknet_py.net.models import AddressRepresentation
 from starknet_py.net.models.transaction import (
     AccountTransaction,
+    DeclareV1,
     DeclareV2,
     DeclareV3,
     DeployAccountV1,
@@ -157,6 +158,31 @@ async def sign_invoke_v3(
         :return: Invoke created from the calls.
         """
 
+    # pylint: disable=line-too-long
+    @abstractmethod
+    async def sign_declare_v1(
+        self,
+        compiled_contract: str,
+        *,
+        nonce: Optional[int] = None,
+        max_fee: Optional[int] = None,
+        auto_estimate: bool = False,
+    ) -> DeclareV1:
+        """
+        This method is deprecated, not covered by tests and will be removed in the future.
+        Please use current version of transaction signing methods.
+
+        Based on https://docs.starknet.io/architecture-and-concepts/network-architecture/transactions/#transaction_versioning
+
+        :param compiled_contract: string containing a compiled Starknet contract. Supports old contracts.
+        :param nonce: Nonce of the transaction.
+        :param max_fee: Max amount of Wei to be paid when executing transaction.
+        :param auto_estimate: Use automatic fee estimation, not recommend as it may lead to high costs.
+        :return: Signed Declare transaction.
+        """
+
+    # pylint: enable=line-too-long
+
     @abstractmethod
     async def sign_declare_v2(
         self,

starknet_py/net/client_models.py

@@ -258,6 +258,16 @@ class InvokeTransactionV3(TransactionV3):
     account_deployment_data: List[int]
 
 
+@dataclass
+class DeclareTransactionV0(DeprecatedTransaction):
+    """
+    Dataclass representing declare transaction v0.
+    """
+
+    sender_address: int
+    class_hash: int
+
+
 @dataclass
 class DeclareTransactionV1(DeprecatedTransaction):
     """

starknet_py/net/models/__init__.py

@@ -2,6 +2,7 @@
 from .chains import StarknetChainId, chain_from_network
 from .transaction import (
     AccountTransaction,
+    DeclareV1,
     DeclareV2,
     DeclareV3,
     DeployAccountV1,

starknet_py/net/models/transaction.py

@@ -10,15 +10,17 @@
 import json
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import List, TypeVar, Union
+from typing import Any, Dict, List, TypeVar, Union
 
+import marshmallow
 import marshmallow_dataclass
 from marshmallow import fields
 
 from starknet_py.hash.address import compute_address
 from starknet_py.hash.transaction import (
     CommonTransactionV3Fields,
     TransactionHashPrefix,
+    compute_declare_transaction_hash,
     compute_declare_v2_transaction_hash,
     compute_declare_v3_transaction_hash,
     compute_deploy_account_transaction_hash,
@@ -28,12 +30,16 @@
 )
 from starknet_py.net.client_models import (
     DAMode,
+    DeprecatedContractClass,
     ResourceBoundsMapping,
     SierraContractClass,
     TransactionType,
 )
 from starknet_py.net.schemas.common import Felt
-from starknet_py.net.schemas.rpc.contract import SierraContractClassSchema
+from starknet_py.net.schemas.rpc.contract import (
+    ContractClassSchema,
+    SierraContractClassSchema,
+)
 
 # TODO (#1219):
 #  consider unifying these classes with client_models
@@ -175,6 +181,59 @@ def calculate_hash(self, chain_id: int) -> int:
         )
 
 
+# pylint: disable=line-too-long
+@dataclass(frozen=True)
+class DeclareV1(_DeprecatedAccountTransaction):
+    """
+    This class is deprecated, not covered by tests and will be removed in the future.
+    Please use current version of transactions.
+
+    Based on https://docs.starknet.io/architecture-and-concepts/network-architecture/transactions/#transaction_versioning
+
+    Represents a transaction in the Starknet network that is a declaration of a Starknet contract
+    class.
+    """
+
+    # The class to be declared, included for all methods involving execution (estimateFee, simulateTransactions)
+    contract_class: DeprecatedContractClass = field(
+        metadata={"marshmallow_field": fields.Nested(ContractClassSchema())}
+    )
+    # The address of the account contract sending the declaration transaction.
+    sender_address: int = field(metadata={"marshmallow_field": Felt()})
+
+    @property
+    def type(self) -> TransactionType:
+        return TransactionType.DECLARE
+
+    @marshmallow.post_dump
+    def post_dump(self, data: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        # Allowing **kwargs is needed here because marshmallow is passing additional parameters here
+        # along with data, which we don't handle.
+        # pylint: disable=unused-argument, no-self-use
+        return compress_program(data)
+
+    @marshmallow.pre_load
+    def pre_load(self, data: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        # pylint: disable=unused-argument, no-self-use
+        return decompress_program(data)
+
+    def calculate_hash(self, chain_id: int) -> int:
+        """
+        Calculates the transaction hash in the Starknet network.
+        """
+        return compute_declare_transaction_hash(
+            contract_class=self.contract_class,
+            chain_id=chain_id,
+            sender_address=self.sender_address,
+            max_fee=self.max_fee,
+            version=self.version,
+            nonce=self.nonce,
+        )
+
+
+# pylint: enable=line-too-long
+
+
 @dataclass(frozen=True)
 class DeployAccountV3(_AccountTransactionV3):
     """
@@ -305,11 +364,12 @@ def calculate_hash(self, chain_id: int) -> int:
         )
 
 
-Declare = Union[DeclareV2, DeclareV3]
+Declare = Union[DeclareV1, DeclareV2, DeclareV3]
 DeployAccount = Union[DeployAccountV1, DeployAccountV3]
 Invoke = Union[InvokeV1, InvokeV3]
 
 InvokeV1Schema = marshmallow_dataclass.class_schema(InvokeV1)
+DeclareV1Schema = marshmallow_dataclass.class_schema(DeclareV1)
 DeclareV2Schema = marshmallow_dataclass.class_schema(DeclareV2)
 DeployAccountV1Schema = marshmallow_dataclass.class_schema(DeployAccountV1)
 

starknet_py/net/schemas/rpc/transactions.py

@@ -4,6 +4,7 @@
 from starknet_py.net.client_models import (
     DAMode,
     DeclareTransactionResponse,
+    DeclareTransactionV0,
     DeclareTransactionV1,
     DeclareTransactionV2,
     DeclareTransactionV3,
@@ -174,6 +175,15 @@ def make_transaction(self, data, **kwargs) -> InvokeTransactionV3:
         return InvokeTransactionV3(**data)
 
 
+class DeclareTransactionV0Schema(DeprecatedTransactionSchema):
+    sender_address = Felt(data_key="sender_address", required=True)
+    class_hash = Felt(data_key="class_hash", required=True)
+
+    @post_load
+    def make_dataclass(self, data, **kwargs) -> DeclareTransactionV0:
+        return DeclareTransactionV0(**data)
+
+
 class DeclareTransactionV1Schema(DeprecatedTransactionSchema):
     sender_address = Felt(data_key="sender_address", required=True)
     class_hash = Felt(data_key="class_hash", required=True)
@@ -250,6 +260,7 @@ def make_dataclass(self, data, **kwargs) -> DeployAccountTransactionV3:
 
 class DeclareTransactionSchema(OneOfSchema):
     type_schemas = {
+        "0": DeclareTransactionV0Schema,
         "1": DeclareTransactionV1Schema,
         "2": DeclareTransactionV2Schema,
         "3": DeclareTransactionV3Schema,