Refactor code for creating broadcasted transaction (#1288)

* Move _create_broadcasted_txn to client utils

* add broadcasted schemas

* refactor

* clean up

* clean up

* fix linter

* rename

* clean up code

* feedback

* revert transaction types

* adds tests

* feedback

* fix

* fix tests

* Remove obsolate code broadcasted txn (#1297)

Author: tkumor3

starknet_py/net/client_test.py

@@ -1,14 +1,30 @@
+import dataclasses
+
 import pytest
 
 from starknet_py.constants import ADDR_BOUND
+from starknet_py.hash.selector import get_selector_from_name
 from starknet_py.net.client_models import (
+    Call,
     DAMode,
     ResourceBoundsMapping,
     Transaction,
+    TransactionType,
     TransactionV3,
 )
+from starknet_py.net.client_utils import _create_broadcasted_txn
 from starknet_py.net.full_node_client import _to_storage_key
 from starknet_py.net.http_client import RpcHttpClient, ServerError
+from starknet_py.net.models.transaction import (
+    DeclareV1,
+    DeclareV2,
+    DeclareV3,
+    DeployAccountV1,
+    DeployAccountV3,
+    InvokeV1,
+    InvokeV3,
+)
+from starknet_py.tests.e2e.fixtures.constants import MAX_FEE, MAX_RESOURCE_BOUNDS_L1
 
 
 @pytest.mark.asyncio
@@ -74,3 +90,118 @@ def test_get_rpc_storage_key(key, expected):
 def test_get_rpc_storage_key_raises_on_non_representable_key(key):
     with pytest.raises(ValueError, match="cannot be represented"):
         _to_storage_key(key)
+
+
+@pytest.mark.asyncio
+async def test_broadcasted_txn_declare_v3(
+    account, abi_types_compiled_contract_and_class_hash
+):
+    declare_v3 = await account.sign_declare_v3(
+        compiled_contract=abi_types_compiled_contract_and_class_hash[0],
+        compiled_class_hash=abi_types_compiled_contract_and_class_hash[1],
+        l1_resource_bounds=MAX_RESOURCE_BOUNDS_L1,
+    )
+
+    brodcasted_txn = _create_broadcasted_txn(declare_v3)
+    assert brodcasted_txn["type"] == TransactionType.DECLARE.name
+
+    expected_keys = dataclasses.fields(DeclareV3)
+    assert all(key.name in brodcasted_txn for key in expected_keys)
+
+
+@pytest.mark.asyncio
+async def test_broadcasted_txn_declare_v2(
+    account, abi_types_compiled_contract_and_class_hash
+):
+    declare_v2 = await account.sign_declare_v2(
+        compiled_contract=abi_types_compiled_contract_and_class_hash[0],
+        compiled_class_hash=abi_types_compiled_contract_and_class_hash[1],
+        max_fee=MAX_FEE,
+    )
+
+    brodcasted_txn = _create_broadcasted_txn(declare_v2)
+
+    assert brodcasted_txn["type"] == TransactionType.DECLARE.name
+
+    expected_keys = dataclasses.fields(DeclareV2)
+    assert all(key.name in brodcasted_txn for key in expected_keys)
+
+
+@pytest.mark.asyncio
+async def test_broadcasted_txn_declare_v1(account, map_compiled_contract):
+    declare_v1 = await account.sign_declare_v1(
+        compiled_contract=map_compiled_contract,
+        max_fee=MAX_FEE,
+    )
+
+    brodcasted_txn = _create_broadcasted_txn(declare_v1)
+
+    assert brodcasted_txn["type"] == TransactionType.DECLARE.name
+
+    expected_keys = dataclasses.fields(DeclareV1)
+    assert all(key.name in brodcasted_txn for key in expected_keys)
+
+
+@pytest.mark.asyncio
+async def test_broadcasted_txn_invoke_v3(account, map_contract):
+    invoke_tx = await account.sign_invoke_v3(
+        calls=Call(map_contract.address, get_selector_from_name("put"), [3, 4]),
+        l1_resource_bounds=MAX_RESOURCE_BOUNDS_L1,
+    )
+
+    brodcasted_txn = _create_broadcasted_txn(invoke_tx)
+
+    assert brodcasted_txn["type"] == TransactionType.INVOKE.name
+
+    expected_keys = dataclasses.fields(InvokeV3)
+    assert all(key.name in brodcasted_txn for key in expected_keys)
+
+
+@pytest.mark.asyncio
+async def test_broadcasted_txn_invoke_v1(account, map_contract):
+    invoke_tx = await account.sign_invoke_v1(
+        calls=Call(map_contract.address, get_selector_from_name("put"), [3, 4]),
+        max_fee=int(1e16),
+    )
+
+    brodcasted_txn = _create_broadcasted_txn(invoke_tx)
+
+    assert brodcasted_txn["type"] == TransactionType.INVOKE.name
+
+    expected_keys = dataclasses.fields(InvokeV1)
+    assert all(key.name in brodcasted_txn for key in expected_keys)
+
+
+@pytest.mark.asyncio
+async def test_broadcasted_txn_deploy_account_v3(account):
+    class_hash = 0x1234
+    salt = 0x123
+    calldata = [1, 2, 3]
+    signed_tx = await account.sign_deploy_account_v3(
+        class_hash,
+        salt,
+        l1_resource_bounds=MAX_RESOURCE_BOUNDS_L1,
+        constructor_calldata=calldata,
+    )
+    brodcasted_txn = _create_broadcasted_txn(signed_tx)
+    assert brodcasted_txn["type"] == TransactionType.DEPLOY_ACCOUNT.name
+
+    expected_keys = dataclasses.fields(DeployAccountV3)
+    assert all(key.name in brodcasted_txn for key in expected_keys)
+
+
+@pytest.mark.asyncio
+async def test_broadcasted_txn_deploy_account_v1(account):
+    class_hash = 0x1234
+    salt = 0x123
+    calldata = [1, 2, 3]
+    signed_tx = await account.sign_deploy_account_v1(
+        class_hash, salt, calldata, max_fee=MAX_FEE
+    )
+
+    brodcasted_txn = _create_broadcasted_txn(signed_tx)
+
+    assert brodcasted_txn["type"] == TransactionType.DEPLOY_ACCOUNT.name
+
+    expected_keys = dataclasses.fields(DeployAccountV1)
+    assert all(key.name in brodcasted_txn for key in expected_keys)

starknet_py/net/client_utils.py

@@ -1,10 +1,12 @@
 import re
-from typing import Union
+from typing import Dict, Union, cast
 
 from typing_extensions import get_args
 
 from starknet_py.hash.utils import encode_uint, encode_uint_list
 from starknet_py.net.client_models import Hash, L1HandlerTransaction, Tag
+from starknet_py.net.models.transaction import AccountTransaction
+from starknet_py.net.schemas.broadcasted_txn import BroadcastedTransactionSchema
 
 
 def hash_to_felt(value: Hash) -> str:
@@ -77,3 +79,10 @@ def _is_valid_eth_address(address: str) -> bool:
     A function checking if an address matches Ethereum address regex. Note that it doesn't validate any checksums etc.
     """
     return bool(re.fullmatch("^0x[a-fA-F0-9]{40}$", address))
+
+
+def _create_broadcasted_txn(transaction: AccountTransaction) -> dict:
+    return cast(
+        Dict,
+        BroadcastedTransactionSchema().dump(obj=transaction),
+    )

starknet_py/net/full_node_client.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Tuple, Union, cast
+from typing import List, Optional, Tuple, Union, cast
 
 import aiohttp
 from marshmallow import EXCLUDE
@@ -34,9 +34,9 @@
     TransactionReceipt,
     TransactionStatusResponse,
     TransactionTrace,
-    TransactionType,
 )
 from starknet_py.net.client_utils import (
+    _create_broadcasted_txn,
     _is_valid_eth_address,
     _to_rpc_felt,
     _to_storage_key,
@@ -46,16 +46,9 @@
 from starknet_py.net.models.transaction import (
     AccountTransaction,
     Declare,
-    DeclareV1Schema,
-    DeclareV2,
-    DeclareV2Schema,
-    DeclareV3,
     DeployAccount,
-    DeployAccountV3,
     Invoke,
-    InvokeV3,
 )
-from starknet_py.net.schemas.gateway import SierraCompiledContractSchema
 from starknet_py.net.schemas.rpc import (
     BlockHashAndNumberSchema,
     BlockStateUpdateSchema,
@@ -77,10 +70,8 @@
     TransactionReceiptSchema,
     TransactionStatusResponseSchema,
     TransactionTraceSchema,
-    TransactionV3Schema,
     TypesOfTransactionsSchema,
 )
-from starknet_py.net.schemas.utils import _extract_tx_version
 from starknet_py.transaction_errors import TransactionNotReceivedError
 from starknet_py.utils.sync import add_sync_methods
 
@@ -810,152 +801,3 @@ def _get_raw_block_identifier(
         return {"block_number": block_number}
 
     return "pending"
-
-
-def _create_broadcasted_txn(transaction: AccountTransaction) -> dict:
-    txn_map = {
-        TransactionType.DECLARE: _create_broadcasted_declare_properties,
-        TransactionType.INVOKE: _create_broadcasted_invoke_properties,
-        TransactionType.DEPLOY_ACCOUNT: _create_broadcasted_deploy_account_properties,
-    }
-
-    common_properties = _create_broadcasted_txn_common_properties(transaction)
-    transaction_specific_properties = txn_map[transaction.type](transaction)
-
-    return {
-        **common_properties,
-        **transaction_specific_properties,
-    }
-
-
-def _create_broadcasted_declare_properties(
-    transaction: Union[Declare, DeclareV2, DeclareV3]
-) -> dict:
-    if isinstance(transaction, DeclareV2):
-        return _create_broadcasted_declare_v2_properties(transaction)
-    if isinstance(transaction, DeclareV3):
-        return _create_broadcasted_declare_v3_properties(transaction)
-
-    contract_class = cast(Dict, DeclareV1Schema().dump(obj=transaction))[
-        "contract_class"
-    ]
-    declare_properties = {
-        "contract_class": {
-            "entry_points_by_type": contract_class["entry_points_by_type"],
-            "program": contract_class["program"],
-        },
-        "sender_address": _to_rpc_felt(transaction.sender_address),
-    }
-    if contract_class["abi"] is not None:
-        declare_properties["contract_class"]["abi"] = contract_class["abi"]
-
-    return declare_properties
-
-
-def _create_broadcasted_declare_v2_properties(transaction: DeclareV2) -> dict:
-    contract_class = cast(Dict, DeclareV2Schema().dump(obj=transaction))[
-        "contract_class"
-    ]
-    declare_v2_properties = {
-        "contract_class": {
-            "entry_points_by_type": contract_class["entry_points_by_type"],
-            "sierra_program": contract_class["sierra_program"],
-            "contract_class_version": contract_class["contract_class_version"],
-        },
-        "sender_address": _to_rpc_felt(transaction.sender_address),
-        "compiled_class_hash": _to_rpc_felt(transaction.compiled_class_hash),
-    }
-    if contract_class["abi"] is not None:
-        declare_v2_properties["contract_class"]["abi"] = contract_class["abi"]
-
-    return declare_v2_properties
-
-
-def _create_broadcasted_declare_v3_properties(transaction: DeclareV3) -> dict:
-    contract_class = cast(
-        Dict, SierraCompiledContractSchema().dump(obj=transaction.contract_class)
-    )
-
-    declare_v3_properties = {
-        "contract_class": {
-            "entry_points_by_type": contract_class["entry_points_by_type"],
-            "sierra_program": contract_class["sierra_program"],
-            "contract_class_version": contract_class["contract_class_version"],
-        },
-        "sender_address": _to_rpc_felt(transaction.sender_address),
-        "compiled_class_hash": _to_rpc_felt(transaction.compiled_class_hash),
-        "account_deployment_data": [
-            _to_rpc_felt(data) for data in transaction.account_deployment_data
-        ],
-    }
-
-    if contract_class["abi"] is not None:
-        declare_v3_properties["contract_class"]["abi"] = contract_class["abi"]
-
-    return {
-        **_create_broadcasted_txn_v3_common_properties(transaction),
-        **declare_v3_properties,
-    }
-
-
-def _create_broadcasted_invoke_properties(transaction: Union[Invoke, InvokeV3]) -> dict:
-    invoke_properties = {
-        "sender_address": _to_rpc_felt(transaction.sender_address),
-        "calldata": [_to_rpc_felt(data) for data in transaction.calldata],
-    }
-
-    if isinstance(transaction, InvokeV3):
-        return {
-            **_create_broadcasted_txn_v3_common_properties(transaction),
-            **invoke_properties,
-            "account_deployment_data": [
-                _to_rpc_felt(data) for data in transaction.account_deployment_data
-            ],
-        }
-
-    return invoke_properties
-
-
-def _create_broadcasted_deploy_account_properties(
-    transaction: Union[DeployAccount, DeployAccountV3]
-) -> dict:
-    deploy_account_txn_properties = {
-        "contract_address_salt": _to_rpc_felt(transaction.contract_address_salt),
-        "constructor_calldata": [
-            _to_rpc_felt(data) for data in transaction.constructor_calldata
-        ],
-        "class_hash": _to_rpc_felt(transaction.class_hash),
-    }
-
-    if isinstance(transaction, DeployAccountV3):
-        return {
-            **_create_broadcasted_txn_v3_common_properties(transaction),
-            **deploy_account_txn_properties,
-        }
-
-    return deploy_account_txn_properties
-
-
-def _create_broadcasted_txn_common_properties(transaction: AccountTransaction) -> dict:
-    broadcasted_txn_common_properties = {
-        "type": transaction.type.name,
-        "version": _to_rpc_felt(transaction.version),
-        "signature": [_to_rpc_felt(sig) for sig in transaction.signature],
-        "nonce": _to_rpc_felt(transaction.nonce),
-    }
-
-    if _extract_tx_version(transaction.version) < 3 and hasattr(transaction, "max_fee"):
-        broadcasted_txn_common_properties["max_fee"] = _to_rpc_felt(
-            transaction.max_fee  # pyright: ignore
-        )
-
-    return broadcasted_txn_common_properties
-
-
-def _create_broadcasted_txn_v3_common_properties(
-    transaction: Union[DeclareV3, InvokeV3, DeployAccountV3]
-) -> dict:
-    return cast(
-        Dict,
-        TransactionV3Schema(exclude=["version", "signature"]).dump(obj=transaction),
-    )