Drop support for deploy tx

starknet_devnet/blueprints/gateway.py

@@ -3,6 +3,7 @@
 """
 
 from flask import Blueprint, jsonify, request
+from starkware.starknet.definitions.error_codes import StarknetErrorCode
 from starkware.starknet.definitions.transaction_type import TransactionType
 from starkware.starkware_utils.error_handling import StarkErrorCode
 
@@ -40,10 +41,10 @@ async def add_transaction():
         response_dict["address"] = fixed_length_hex(contract_address)
 
     elif tx_type == TransactionType.DEPLOY:
-        contract_address, transaction_hash = await state.starknet_wrapper.deploy(
-            transaction
+        raise StarknetDevnetException(
+            code=StarknetErrorCode.DEPRECATED_TRANSACTION,
+            message="Deploy transaction is no longer supported.",
         )
-        response_dict["address"] = fixed_length_hex(contract_address)
 
     elif tx_type == TransactionType.INVOKE_FUNCTION:
         (contract_address, transaction_hash) = await state.starknet_wrapper.invoke(

starknet_devnet/blueprints/rpc/routes.py

@@ -39,7 +39,6 @@
 from starknet_devnet.blueprints.rpc.transactions import (
     add_declare_transaction,
     add_deploy_account_transaction,
-    add_deploy_transaction,
     add_invoke_transaction,
     estimate_fee,
     get_transaction_by_block_id_and_index,
@@ -73,7 +72,6 @@
     "getNonce": get_nonce,
     "addInvokeTransaction": add_invoke_transaction,
     "addDeclareTransaction": add_declare_transaction,
-    "addDeployTransaction": add_deploy_transaction,
     "addDeployAccountTransaction": add_deploy_account_transaction,
 }
 

starknet_devnet/blueprints/rpc/structures/payloads.py

@@ -26,7 +26,6 @@
     TransactionType,
 )
 from starkware.starknet.services.api.gateway.transaction import (
-    Deploy,
     DeployAccount,
     DeprecatedDeclare,
     InvokeFunction,
@@ -457,31 +456,6 @@ def make_declare(declare_transaction: RpcBroadcastedDeclareTxn) -> DeprecatedDec
     return declare_tx
 
 
-def make_deploy(deploy_transaction: RpcBroadcastedDeployTxn) -> Deploy:
-    """
-    Convert RpcBroadcastedDeployTxn to Deploy
-    """
-    contract_class = deploy_transaction["contract_class"]
-    if "abi" not in contract_class:
-        contract_class["abi"] = []
-
-    try:
-        contract_class["program"] = decompress_program(contract_class["program"])
-        contract_class = DeprecatedCompiledClass.load(contract_class)
-    except (StarkException, TypeError, MarshmallowError) as ex:
-        raise RpcError(code=50, message="Invalid contract class") from ex
-
-    deploy_tx = Deploy(
-        contract_address_salt=int(deploy_transaction["contract_address_salt"], 16),
-        constructor_calldata=[
-            int(data, 16) for data in deploy_transaction["constructor_calldata"]
-        ],
-        contract_definition=contract_class,
-        version=int(deploy_transaction["version"], 16),
-    )
-    return deploy_tx
-
-
 def make_deploy_account(
     deploy_account_transaction: RpcBroadcastedDeployAccountTxn,
 ) -> DeployAccount:

starknet_devnet/blueprints/rpc/transactions.py

@@ -14,12 +14,10 @@
 from starknet_devnet.blueprints.rpc.structures.payloads import (
     RpcBroadcastedDeclareTxn,
     RpcBroadcastedDeployAccountTxn,
-    RpcBroadcastedDeployTxn,
     RpcBroadcastedInvokeTxn,
     RpcBroadcastedTxn,
     RpcTransaction,
     make_declare,
-    make_deploy,
     make_deploy_account,
     make_invoke_function,
     rpc_fee_estimate,
@@ -28,7 +26,6 @@
 from starknet_devnet.blueprints.rpc.structures.responses import (
     RpcDeclareTransactionResult,
     RpcDeployAccountTransactionResult,
-    RpcDeployTransactionResult,
     RpcInvokeTransactionResult,
     rpc_transaction_receipt,
 )
@@ -135,22 +132,6 @@ async def add_declare_transaction(
     )
 
 
-@validate_schema("addDeployTransaction")
-async def add_deploy_transaction(deploy_transaction: RpcBroadcastedDeployTxn) -> dict:
-    """
-    Submit a new deploy contract transaction
-    """
-    deploy_transaction = make_deploy(deploy_transaction)
-
-    contract_address, transaction_hash = await state.starknet_wrapper.deploy(
-        deploy_transaction=deploy_transaction
-    )
-    return RpcDeployTransactionResult(
-        transaction_hash=rpc_felt(transaction_hash),
-        contract_address=rpc_felt(contract_address),
-    )
-
-
 @validate_schema("addDeployAccountTransaction")
 async def add_deploy_account_transaction(
     deploy_account_transaction: RpcBroadcastedDeployAccountTxn,
@@ -189,7 +170,7 @@ def make_transaction(txn: RpcBroadcastedTxn) -> AccountTransaction:
     if txn_type == "DECLARE":
         return make_declare(txn)
     if txn_type == "DEPLOY":
-        return make_deploy(txn)
+        raise RpcError(code=-1, message="DEPLOY transactions are deprecated")
     if txn_type == "DEPLOY_ACCOUNT":
         return make_deploy_account(txn)
     raise NotImplementedError(f"Unexpected type {txn_type}.")

starknet_devnet/starknet_wrapper.py

@@ -25,9 +25,6 @@
 from starkware.starknet.core.os.contract_class.compiled_class_hash import (
     compute_compiled_class_hash,
 )
-from starkware.starknet.core.os.transaction_hash.transaction_hash import (
-    calculate_deploy_transaction_hash,
-)
 from starkware.starknet.definitions.error_codes import StarknetErrorCode
 from starkware.starknet.definitions.transaction_type import TransactionType
 from starkware.starknet.services.api.contract_class.contract_class import (
@@ -54,7 +51,6 @@
 )
 from starkware.starknet.services.api.gateway.transaction import (
     Declare,
-    Deploy,
     DeployAccount,
     DeprecatedDeclare,
     InvokeFunction,
@@ -114,6 +110,7 @@
 
 DEFAULT_BLOCK_ID = LATEST_BLOCK_ID
 
+
 # pylint: disable=too-many-instance-attributes
 # pylint: disable=too-many-public-methods
 # pylint: disable=too-many-locals
@@ -215,6 +212,7 @@ async def __create_genesis_block(self):
             deploy_data.append((account.class_hash, account.address))
 
         for class_hash, contract_address in deploy_data:
+            # this might be the only place where DEPLOY tx is used
             internal_deploy = create_empty_internal_deploy(
                 transaction_hash, class_hash, contract_address
             )
@@ -543,53 +541,6 @@ async def deploy_account(self, external_tx: DeployAccount):
             tx_handler.internal_tx.hash_value,
         )
 
-    async def deploy(self, deploy_transaction: Deploy) -> Tuple[int, int]:
-        """
-        Deploys the contract specified with `deploy_transaction`.
-        Returns (contract_address, transaction_hash).
-        """
-
-        contract_class = deploy_transaction.contract_definition
-
-        internal_tx: InternalDeploy = InternalDeploy.from_external(
-            deploy_transaction, self.get_state().general_config
-        )
-
-        contract_address = internal_tx.contract_address
-
-        if await self.is_deployed(contract_address):
-            tx_hash = calculate_deploy_transaction_hash(
-                version=deploy_transaction.version,
-                contract_address=contract_address,
-                constructor_calldata=deploy_transaction.constructor_calldata,
-                chain_id=self.get_state().general_config.chain_id.value,
-            )
-            return contract_address, tx_hash
-
-        tx_hash = internal_tx.hash_value
-
-        async with self.__get_transaction_handler(
-            external_tx=deploy_transaction
-        ) as tx_handler:
-            tx_handler.internal_tx = internal_tx
-            state = self.get_state().state
-            state.contract_classes[internal_tx.class_hash] = contract_class
-            self._contract_classes[internal_tx.class_hash] = contract_class
-
-            tx_handler.execution_info = await self.__deploy(internal_tx)
-            tx_handler.internal_calls = (
-                tx_handler.execution_info.call_info.internal_calls
-            )
-
-            tx_handler.deployed_contracts.append(
-                ContractAddressHashPair(
-                    address=contract_address,
-                    class_hash=internal_tx.class_hash,
-                )
-            )
-
-        return contract_address, tx_hash
-
     async def invoke(self, external_tx: InvokeFunction):
         """Perform invoke according to specifications in `transaction`."""
         state = self.get_state()