Deploy through Accounts

README.md

@@ -119,7 +119,7 @@ Creating artifacts/abis/ to store compilation artifacts
 
 ### `deploy`
 
-> NOTICE: this method doesn't use an account, which will be deprecated very soon as StarkNet makes deployments from accounts mandatory.
+> NOTICE: Calling this method will require an account very soon (using the `--account` param) as StarkNet will make deployments from accounts mandatory.
 
 > Token for deployments to Alpha Mainnet can be set with the `--token` option.
 
@@ -128,21 +128,24 @@ nile deploy <contract> [--alias ALIAS] [--network NETWORK] [--track | --debug]
 ```
 
 ```sh
-nile deploy contract --alias my_contract
+nile deploy contract --account setup_account_alias --alias my_contract
 
 🚀 Deploying contract
-🌕 artifacts/contract.json successfully deployed to 0x07ec10eb0758f7b1bc5aed0d5b4d30db0ab3c087eba85d60858be46c1a5e4680
+⏳ ️Deployment of contract successfully sent at 0x07ec10eb0758f7b1bc5aed0d5b4d30db0ab3c087eba85d60858be46c1a5e4680
+🧾 Transaction hash: 0x79e596c39cfec555f2d17253d043a0defd64a851a268b68c13811f328baf123
 📦 Registering deployment as my_contract in localhost.deployments.txt
 ```
 
 A few things to note here:
 
-- `nile deploy <contract_name>` looks for an artifact with the same name.
-- This creates or updates the `localhost.deployments.txt` file storing all data related to deployments.
-- The `--alias` parameter creates a unique identifier for future interactions, if no alias is set then the contract's address can be used as identifier.
-- By default Nile works on local, but you can use the `--network` parameter to interact with `mainnet`, `goerli`, and the default `localhost`.
-- By default, the ABI corresponding to the contract will be registered with the deployment. To register a different ABI file, use the `--abi` parameter.
-- `--track` and `--debug` flags can be used to watch the status of the deployment transaction. See `status` below for a complete description.
+1. `nile deploy <contract_name>` looks for an artifact with the same name.
+2. This creates or updates the `localhost.deployments.txt` file storing all data related to deployments.
+3. The `--account` parameter deploys using the provided account and the UniversalDeployer contract.
+4. The `--alias` parameter creates a unique identifier for future interactions, if no alias is set then the contract's address can be used as identifier.
+5. The `--deployer_address` parameter lets you specify the deployer contract address if needed.
+6. By default Nile works on local, but you can use the `--network` parameter to interact with `mainnet`, `goerli`, `goerli2`, `integration`, and the default `localhost`.
+7. By default, the ABI corresponding to the contract will be registered with the deployment. To register a different ABI file, use the `--abi` parameter.
+8. `--track` and `--debug` flags can be used to watch the status of the deployment transaction. See `status` below for a complete description.
 
 ### `setup`
 

src/nile/cli.py

@@ -91,24 +91,62 @@ def run(path, network):
 
 
 @cli.command()
-@click.argument("artifact", nargs=1)
-@click.argument("arguments", nargs=-1)
+@click.argument("signer", nargs=1)
+@click.argument("contract_name", nargs=1)
+@click.argument("params", nargs=-1)
+@click.option("--max_fee", nargs=1)
+@click.option("--salt", nargs=1, default=0)
+@click.option("--unique", is_flag=True)
 @click.option("--alias")
 @click.option("--abi")
-@network_option
+@click.option("--deployer_address")
+@click.option(
+    "--ignore_account",
+    is_flag=True,
+    help="Deploy without Account.",
+)
 @mainnet_token_option
+@network_option
 @watch_option
-def deploy(artifact, arguments, network, alias, watch_mode, abi, token):
-    """Deploy StarkNet smart contract."""
-    deploy_command(
-        contract_name=artifact,
-        arguments=arguments,
-        network=network,
-        alias=alias,
-        abi=abi,
-        mainnet_token=token,
-        watch_mode=watch_mode,
-    )
+def deploy(
+    signer,
+    contract_name,
+    salt,
+    params,
+    max_fee,
+    unique,
+    alias,
+    abi,
+    deployer_address,
+    ignore_account,
+    token,
+    network,
+    watch_mode,
+):
+    """Deploy a StarkNet smart contract."""
+    if not ignore_account:
+        account = Account(signer, network)
+        account.deploy_contract(
+            contract_name,
+            salt,
+            unique,
+            params,
+            alias,
+            deployer_address=deployer_address,
+            max_fee=max_fee,
+            abi=abi,
+            watch_mode=watch_mode,
+        )
+    else:
+        deploy_command(
+            contract_name,
+            params,
+            network,
+            alias,
+            abi=abi,
+            mainnet_token=token,
+            watch_mode=watch_mode,
+        )
 
 
 @cli.command()
@@ -130,7 +168,7 @@ def declare(
     overriding_path,
     token,
 ):
-    """Declare StarkNet smart contract."""
+    """Declare a StarkNet smart contract through an Account."""
     account = Account(signer, network)
     account.declare(
         contract_name,

src/nile/common.py

@@ -215,7 +215,7 @@ def get_contract_class(contract_name, overriding_path=None):
     return contract_class
 
 
-def get_hash(contract_name, overriding_path=None):
+def get_class_hash(contract_name, overriding_path=None):
     """Return the class_hash for a given contract name."""
     contract_class = get_contract_class(contract_name, overriding_path)
     return hex_class_hash(

src/nile/core/account.py

@@ -16,6 +16,7 @@
 from nile.core.call_or_invoke import call_or_invoke
 from nile.core.declare import declare
 from nile.core.deploy import deploy
+from nile.core.deploy import deploy_contract as deploy_with_deployer
 from nile.utils.get_nonce import get_nonce_without_log as get_nonce
 
 try:
@@ -64,6 +65,8 @@ def __init__(self, signer, network, predeployed_info=None, watch_mode=None):
             self.address = address
             self.index = index
 
+        assert type(self.address) == int
+
     def deploy(self, watch_mode=None):
         """Deploy an Account contract for the given private key."""
         index = accounts.current_index(self.network)
@@ -95,20 +98,14 @@ def declare(
         mainnet_token=None,
         watch_mode=None,
     ):
-        """Declare a contract through an Account contract."""
-        if nonce is None:
-            nonce = get_nonce(self.address, self.network)
-
-        if max_fee is None:
-            max_fee = 0
-        else:
-            max_fee = int(max_fee)
+        """Declare a contract through an Account."""
+        _, max_fee, nonce = self._process_arguments([], max_fee, nonce)
 
         contract_class = get_contract_class(
             contract_name=contract_name, overriding_path=overriding_path
         )
 
-        sig_r, sig_s = self.signer.sign_declare(
+        sig_r, sig_s = self.signer.sign_declare_tx(
             sender=self.address,
             contract_class=contract_class,
             nonce=nonce,
@@ -127,14 +124,33 @@ def declare(
         )
 
     def deploy_contract(
-        self, class_hash, salt, unique, calldata, max_fee=None, deployer_address=None
+        self,
+        contract_name,
+        salt,
+        unique,
+        calldata,
+        alias,
+        max_fee=None,
+        deployer_address=None,
+        abi=None,
+        watch_mode=None,
     ):
-        """Deploy a contract through an Account contract."""
-        return self.send(
-            to=deployer_address or UNIVERSAL_DEPLOYER_ADDRESS,
-            method="deployContract",
-            calldata=[class_hash, salt, unique, len(calldata), *calldata],
-            max_fee=max_fee,
+        """Deploy a contract through an Account."""
+        deployer_address = normalize_number(
+            deployer_address or UNIVERSAL_DEPLOYER_ADDRESS
+        )
+
+        deploy_with_deployer(
+            self,
+            contract_name,
+            salt,
+            unique,
+            calldata,
+            alias,
+            deployer_address,
+            max_fee,
+            abi=abi,
+            watch_mode=watch_mode,
         )
 
     def send(
@@ -147,17 +163,14 @@ def send(
         query_type=None,
         watch_mode=None,
     ):
-        """Execute a query or invoke call for a tx going through an Account contract."""
-        # get target address with the right format
+        """Execute a query or invoke call for a tx going through an Account."""
         target_address = self._get_target_address(address_or_alias)
 
-        # process and parse arguments
         calldata, max_fee, nonce = self._process_arguments(calldata, max_fee, nonce)
 
-        # get tx version
         tx_version = QUERY_VERSION if query_type else TRANSACTION_VERSION
 
-        calldata, sig_r, sig_s = self.signer.sign_transaction(
+        calldata, sig_r, sig_s = self.signer.sign_invoke_tx(
             sender=self.address,
             calls=[[target_address, method, calldata]],
             nonce=nonce,
@@ -193,10 +206,9 @@ def _get_target_address(self, address_or_alias):
         if not is_alias(address_or_alias):
             address_or_alias = normalize_number(address_or_alias)
 
-        target_address, _ = (
-            next(deployments.load(address_or_alias, self.network), None)
-            or address_or_alias
-        )
+        target_address, _ = next(
+            deployments.load(address_or_alias, self.network), None
+        ) or (address_or_alias, None)
 
         return target_address
 

src/nile/core/deploy.py

@@ -1,8 +1,19 @@
 """Command to deploy StarkNet smart contracts."""
 import logging
 
+from starkware.cairo.common.hash_chain import compute_hash_chain
+from starkware.starknet.core.os.contract_address.contract_address import (
+    calculate_contract_address_from_hash,
+)
+
 from nile import deployments
-from nile.common import ABIS_DIRECTORY, BUILD_DIRECTORY, parse_information, run_command
+from nile.common import (
+    ABIS_DIRECTORY,
+    BUILD_DIRECTORY,
+    get_class_hash,
+    parse_information,
+    run_command,
+)
 from nile.utils import hex_address
 from nile.utils.status import status
 
@@ -17,8 +28,12 @@ def deploy(
     mainnet_token=None,
     watch_mode=None,
 ):
-    """Deploy StarkNet smart contracts."""
-    logging.info(f"🚀 Deploying {contract_name}")
+    """Deploy StarkNet smart contracts (DEPRECATED)."""
+    logging.info(
+        f"🚀 Deploying {contract_name} without Account. "
+        + "This method is deprecated and will be removed soon. "
+        + "Use the --account option."
+    )
     base_path = (
         overriding_path if overriding_path else (BUILD_DIRECTORY, ABIS_DIRECTORY)
     )
@@ -47,3 +62,60 @@ def deploy(
             return
 
     return address, register_abi
+
+
+def deploy_contract(
+    account,
+    contract_name,
+    salt,
+    unique,
+    calldata,
+    alias,
+    deployer_address,
+    max_fee,
+    overriding_path=None,
+    abi=None,
+    watch_mode=None,
+):
+    """Deploy StarkNet smart contracts."""
+    logging.info(f"🚀 Deploying {contract_name}")
+
+    base_path = (
+        overriding_path if overriding_path else (BUILD_DIRECTORY, ABIS_DIRECTORY)
+    )
+    register_abi = abi if abi is not None else f"{base_path[1]}/{contract_name}.json"
+    deployer_for_address_generation = 0
+
+    if unique:
+        # Match UDC address generation
+        salt = compute_hash_chain(data=[account.address, salt])
+        deployer_for_address_generation = deployer_address
+
+    # This needs to be fixed following the Hex/Int Pattern
+    class_hash = int(get_class_hash(contract_name=contract_name), 16)
+
+    address = calculate_contract_address_from_hash(
+        salt, class_hash, calldata, deployer_for_address_generation
+    )
+
+    output = account.send(
+        deployer_address,
+        method="deployContract",
+        calldata=[class_hash, salt, unique, len(calldata), *calldata],
+        max_fee=max_fee,
+    )
+
+    _, tx_hash = parse_information(output)
+    logging.info(
+        f"⏳ ️Deployment of {contract_name} successfully sent at {hex_address(address)}"
+    )
+    logging.info(f"🧾 Transaction hash: {hex(tx_hash)}")
+
+    deployments.register(address, register_abi, account.network, alias)
+
+    if watch_mode is not None:
+        if status(tx_hash, account.network, watch_mode).status.is_rejected:
+            deployments.unregister(address, account.network, alias, abi=register_abi)
+            return
+
+    return address, register_abi

src/nile/signer.py

@@ -29,12 +29,12 @@ def sign(self, message_hash):
         """Sign a message hash."""
         return sign(msg_hash=message_hash, priv_key=self.private_key)
 
-    def sign_declare(self, sender, contract_class, nonce, max_fee):
+    def sign_declare_tx(self, sender, contract_class, nonce, max_fee):
         """Sign a declare transaction."""
         if isinstance(sender, str):
             sender = int(sender, 16)
 
-        transaction_hash = get_declare_hash(
+        transaction_hash = get_declare_tx_hash(
             sender=sender,
             contract_class=contract_class,
             max_fee=max_fee,
@@ -44,10 +44,10 @@ def sign_declare(self, sender, contract_class, nonce, max_fee):
 
         return self.sign(message_hash=transaction_hash)
 
-    def sign_transaction(
+    def sign_invoke_tx(
         self, sender, calls, nonce, max_fee, version=TRANSACTION_VERSION
     ):
-        """Sign a transaction."""
+        """Sign an invoke transaction."""
         call_array, calldata = from_call_to_call_array(calls)
         execute_calldata = [
             len(call_array),
@@ -93,7 +93,7 @@ def from_call_to_call_array(calls):
     return (call_array, calldata)
 
 
-def get_declare_hash(sender, contract_class, max_fee, nonce, chain_id):
+def get_declare_tx_hash(sender, contract_class, max_fee, nonce, chain_id):
     """Compute the hash of a declare transaction."""
     return calculate_declare_transaction_hash(
         contract_class=contract_class,