Update scripts guide (#4853)

* update scripts guide to remove deployment example
* de-emphasize scripts in general

Author: zoeyTM

docs/src/content/hardhat-network/docs/guides/forking-other-networks.md

@@ -73,7 +73,7 @@ Hardhat Network will by default fork from a recent mainnet block. While this mig
 
 There are two reasons for this:
 
-- The state your tests run against may change between runs. This could cause your tests or scripts to behave differently.
+- The state your tests run against may change between runs. This could cause your tests to behave differently.
 - Pinning enables caching. Every time data is fetched from mainnet, Hardhat Network caches it on disk to speed up future access. If you don't pin the block, there's going to be new data with each new block and the cache won't be useful. We measured up to 20x speed improvements with block pinning.
 
 **You will need access to a node with archival data for this to work.** This is why we recommend [Infura] or [Alchemy], since their free plans include archival data.

docs/src/content/hardhat-network/docs/overview/index.md

@@ -25,11 +25,11 @@ When Hardhat executes your tests, scripts or tasks, an in-process Hardhat Networ
 
 There's no need to make any changes to your tests or scripts.
 
-Hardhat Network is simply another network. If you wanted to be explicit, you could run, for example, `npx hardhat run --network hardhat scripts/my-script.js`.
+Hardhat Network is simply another network. If you wanted to be explicit, you could run, for example, `npx hardhat ignition deploy ./ignition/modules/MyModule.ts --network hardhat`.
 
 ### Running stand-alone in order to support wallets and other software
 
-Alternatively, Hardhat Network can run in a stand-alone fashion so that external clients can connect to it. This could be a wallet, your Dapp front-end, or a script. To run Hardhat Network in this way, run:
+Alternatively, Hardhat Network can run in a stand-alone fashion so that external clients can connect to it. This could be a wallet, your Dapp front-end, or a Hardhat Ignition deployment. To run Hardhat Network in this way, run:
 
 ```
 $ npx hardhat node

docs/src/content/hardhat-runner/docs/advanced/building-plugins.md

@@ -12,7 +12,7 @@ Some examples of things you could achieve by creating a plugin are: running a li
 
 ## Extending the Hardhat Runtime Environment
 
-Let’s go through the process of creating a plugin that adds new functionality to the Hardhat Runtime Environment. By doing this, we make sure our new feature is available everywhere. This means your plugin users can access it from tasks, tests, scripts, and the Hardhat console.
+Let’s go through the process of creating a plugin that adds new functionality to the Hardhat Runtime Environment. By doing this, we make sure our new feature is available everywhere. This means your plugin users can access it from tasks, tests, scripts and the Hardhat console.
 
 The Hardhat Runtime Environment (HRE) is configured through a queue of extension functions that you can add to using the `extendEnvironment()` function. It receives one parameter which is a callback which will be executed after the HRE is initialized. If `extendEnvironment` is called multiple times, its callbacks will be executed in order.
 
@@ -129,7 +129,7 @@ An example on how to add fields to the Hardhat config can be found in [`src/inde
 
 To show better stack traces to your users when an error is meant to interrupt a task's execution, please consider throwing `HardhatPluginError` errors, which can be found in `hardhat/plugins`.
 
-If your error originated in your user's code, like a test or script calling one of your functions, you shouldn't use `HardhatPluginError`.
+If your error originated in your user's code, like a test calling one of your functions, you shouldn't use `HardhatPluginError`.
 
 ### Optimizing your plugin for better startup time
 

docs/src/content/hardhat-runner/docs/advanced/scripts.md

@@ -1,10 +1,8 @@
 # Writing scripts with Hardhat
 
-<!-- TODO: We should write this guide based on a different common use case for scripts now that Ignition exists -->
-
 In this guide we will go through the steps of creating a script with Hardhat. For a general overview of using Hardhat refer to the [Getting started guide](../getting-started/index.md).
 
-You can write your own custom scripts that can use all of Hardhat's functionality. A classic use case is writing a deployment script for your smart contracts.
+You can write your own custom scripts that can use all of Hardhat's functionality. A classic use case is writing a script that prints the list of available accounts.
 
 There are two ways of writing a script that accesses the [Hardhat Runtime Environment](../advanced/hardhat-runtime-environment.md).
 
@@ -26,45 +24,32 @@ const hre = require("hardhat");
 
 You can get access to all your tasks and plugins. To run these scripts you simply go through node: `node script.js`.
 
-To try this out, let's look at [a fresh Hardhat project](../guides/project-setup.md). Run `npx hardhat init` and go through the steps to create a JavaScript project. When you're done, your project directory should look like this:
-
-```
-$ ls -l
-total 400
-drwxr-xr-x    3 fzeoli  staff      96 Jul 30 15:27 contracts
--rw-r--r--    1 fzeoli  staff     195 Jul 30 15:27 hardhat.config.js
-drwxr-xr-x  502 fzeoli  staff   16064 Jul 30 15:31 node_modules
--rw-r--r--    1 fzeoli  staff  194953 Jul 30 15:31 package-lock.json
--rw-r--r--    1 fzeoli  staff     365 Jul 30 15:31 package.json
-drwxr-xr-x    3 fzeoli  staff      96 Jul 30 15:27 scripts
-drwxr-xr-x    3 fzeoli  staff      96 Jul 30 15:27 test
-```
+To try this out, create a new directory called `scripts` in your project's root directory. Then, inside that directory, create a file called `accounts.js` with the following content:
 
-Inside `scripts/` you will find `deploy.js`. Read through its comments to have a better idea of what it does.
+```js
+const hre = require("hardhat");
 
-<!-- FIX: What needs to be swapped in for this? -->
-<!-- <<< @/../packages/hardhat-core/sample-projects/javascript/scripts/deploy.js -->
+async function main() {
+  const accounts = await hre.ethers.getSigners();
 
-Now run the script:
+  for (const account of accounts) {
+    console.log(account.address);
+  }
+}
 
-```
-$ node scripts/deploy.js
-Lock with 1 ETH deployed to: 0x5FbDB2315678afecb367f032d93F642f64180aa3
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
 ```
 
-By accessing the [Hardhat Runtime Environment](../advanced/hardhat-runtime-environment.md) at the top, you are allowed to run the script in a standalone fashion.
-
-Hardhat always runs the compile task when it's invoked via `npx hardhat run`, but in a standalone fashion you may want to call compile manually to make sure everything is compiled. This can be done by calling `hre.run("compile")`. Add the following line at the beginning of the `main` function and re-run the script with node:
+Now run the script:
 
-```js
-await hre.run("compile");
+```sh
+node scripts/accounts.js
 ```
 
-```
-$ node scripts/deploy.js
-Nothing to compile
-Lock with 1 ETH deployed to: 0x5FbDB2315678afecb367f032d93F642f64180aa3
-```
+By accessing the [Hardhat Runtime Environment](../advanced/hardhat-runtime-environment.md) at the top, you are allowed to run the script in a standalone fashion.
 
 ### Hardhat arguments
 

docs/src/content/hardhat-runner/docs/getting-started/index.md

@@ -65,7 +65,7 @@ If you are using Windows, we **strongly recommend** using [WSL 2](https://docs.m
 
 :::
 
-We will explore the basics of creating a Hardhat project with a sample contract, tests of that contract, and a script to deploy it.
+We will explore the basics of creating a Hardhat project with a sample contract, tests of that contract, and a Hardhat Ignition module to deploy it.
 
 To create the sample project, run `npx hardhat init` in your project folder:
 
@@ -321,7 +321,7 @@ To learn more check out the [Hardhat Ignition documentation](/ignition).
 
 ### Connecting a wallet or Dapp to Hardhat Network
 
-By default, Hardhat will spin up a new in-memory instance of Hardhat Network on startup. It's also possible to run Hardhat Network in a standalone fashion so that external clients can connect to it. This could be a wallet, your Dapp front-end, or a script.
+By default, Hardhat will spin up a new in-memory instance of Hardhat Network on startup. It's also possible to run Hardhat Network in a standalone fashion so that external clients can connect to it. This could be a wallet, your Dapp front-end, or a Hardhat Ignition deployment.
 
 To run Hardhat Network in this way, run `npx hardhat node`:
 

docs/src/content/hardhat-runner/docs/guides/_dirinfo.yaml

@@ -6,7 +6,7 @@ order:
   - /test-contracts
   - /deploying
   - /verifying
-  - /tasks-and-scripts
+  - /tasks
   - /hardhat-console
   - /typescript
   - /command-line-completion

docs/src/content/hardhat-runner/docs/guides/hardhat-console.md

@@ -11,7 +11,7 @@ Type ".help" for more information.
 
 The `compile` task will be called before opening the console prompt, but you can skip this with the `--no-compile` parameter.
 
-The execution environment for the console is the same as for tasks, scripts and tests. This means the configuration has been processed, and the [Hardhat Runtime Environment] has been initialized and injected into the global scope.
+The execution environment for the console is the same as for tasks and tests. This means the configuration has been processed, and the [Hardhat Runtime Environment] has been initialized and injected into the global scope.
 
 For example, you'll have access in the global scope to the `config` object:
 

docs/src/content/hardhat-runner/docs/guides/project-setup.md

@@ -111,7 +111,6 @@ The initialized project has the following structure:
 ```
 contracts/
 ignition/modules/
-scripts/
 test/
 hardhat.config.js
 ```
@@ -121,7 +120,6 @@ These are the default paths for a Hardhat project.
 - `contracts/` is where the source files for your contracts should be.
 - `ignition/modules/` is where the Ignition modules that handle contract deployments should be.
 - `test/` is where your tests should go.
-- `scripts/` is where simple automation scripts go.
 
 If you need to change these paths, take a look at the [paths configuration section](../config/index.md#path-configuration).
 

docs/src/content/hardhat-runner/docs/guides/tasks-and-scripts.md

@@ -0,0 +1,42 @@
+# Writing tasks
+
+At its core, Hardhat is a task runner that allows you to automate your development workflow. It comes with some built-in tasks, like `compile` and `test`, but you can add your own custom tasks as well.
+
+This guide will show you how to extend Hardhat's functionality using tasks. It assumes you have initialized a sample project. If you haven't done it, please read [this guide](./project-setup.md) first.
+
+## Writing Hardhat Tasks
+
+Let's write a very simple task that prints the list of available accounts, and explore how it works.
+
+Copy this task definition and paste it into your hardhat config file:
+
+```js
+task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
+  const accounts = await hre.ethers.getSigners();
+
+  for (const account of accounts) {
+    console.log(account.address);
+  }
+});
+```
+
+Now you should be able to run it:
+
+```
+npx hardhat accounts
+```
+
+We are using the `task` function to define our new task. Its first argument is the name of the task, and it's what we use in the command line to run it. The second argument is the description of the task, which is printed when you use `npx hardhat help`.
+
+The third argument is an async function that gets executed when you run the task. It receives two arguments:
+
+1. An object with the arguments for the task. We didn't define any yet.
+2. The [Hardhat Runtime Environment](../advanced/hardhat-runtime-environment.md) or HRE, which contains all the functionality of Hardhat and its plugins. You can also find all of its properties injected into the `global` namespace during the task execution.
+
+You are free to do anything you want in this function. In this case, we use `ethers.getSigners()` to obtain all the configured accounts and print each of their addresses.
+
+You can add parameters to your tasks, and Hardhat will handle their parsing and validation for you.
+
+You can also override existing tasks, which allows you to change how different parts of Hardhat work.
+
+To learn more about tasks, please read [this guide](../advanced/create-task).

docs/src/content/hardhat-runner/docs/guides/tasks.md

@@ -90,7 +90,7 @@ drwxr-xr-x    3 pato  wheel      96 Oct 20 12:50 contracts/
 drwxr-xr-x  434 pato  wheel   13888 Oct 20 12:52 node_modules/
 -rw-r--r--    1 pato  wheel  604835 Oct 20 12:52 package-lock.json
 -rw-r--r--    1 pato  wheel     460 Oct 20 12:52 package.json
-drwxr-xr-x    3 pato  wheel      96 Oct 20 12:50 scripts/
+drwxr-xr-x    3 pato  wheel      96 Oct 20 12:50 ignition/modules/
 drwxr-xr-x    3 pato  wheel      96 Oct 20 12:50 test/
 ```
 
@@ -118,7 +118,7 @@ Finally, you need to create a [`tsconfig.json`](https://www.typescriptlang.org/d
 
 <<< @/../packages/hardhat-core/sample-projects/typescript/tsconfig.json
 
-And that's really all it takes. Now you can write your config, tests, tasks and scripts in TypeScript.
+And that's really all it takes. Now you can write your config, tests, tasks and Ignition modules in TypeScript.
 
 ## Type-checking your project
 
@@ -128,11 +128,11 @@ For example, if you run `npx hardhat test` and one of your tests has a compilati
 
 Since type-checking adds significant overhead, we recommend to do it only in your CI or in pre-commit/pre-push hooks.
 
-## Writing tests and scripts in TypeScript
+## Writing tests in TypeScript
 
 When using JavaScript, all the properties in the [Hardhat Runtime Environment](../advanced/hardhat-runtime-environment.md) are injected into the global scope. When using TypeScript nothing will be available in the global scope and you will need to import everything explicitly using, for example, `import { ethers } from "hardhat"`.
 
-Follow the [Getting started guide](../getting-started/index.md) and create a TypeScript project for a complete example on how to write tests and scripts using TypeScript.
+Follow the [Getting started guide](../getting-started/index.md) and create a TypeScript project for a complete example on how to write tests using TypeScript.
 
 ## Type-safe smart contract interactions
 
@@ -157,7 +157,7 @@ Typescript allows defining custom [path mappings](https://www.typescriptlang.org
 }
 ```
 
-To support this option when running Hardhat tests or scripts, you need to install the package [`tsconfig-paths`](https://www.npmjs.com/package/tsconfig-paths) and register it in your `hardhat.config.ts`:
+To support this option when running Hardhat tests, you need to install the package [`tsconfig-paths`](https://www.npmjs.com/package/tsconfig-paths) and register it in your `hardhat.config.ts`:
 
 ```typescript
 import { HardhatUserConfig } from "hardhat/config";
@@ -172,9 +172,9 @@ const config: HardhatUserConfig = {
 export default config;
 ```
 
-## Running your tests and scripts directly with `ts-node`
+## Running your tests directly with `ts-node`
 
-When running Hardhat scripts without the CLI, you need to use `ts-node`'s [`--files` flag](https://www.npmjs.com/package/ts-node#help-my-types-are-missing).
+When running Hardhat tests without the CLI, you need to use `ts-node`'s [`--files` flag](https://www.npmjs.com/package/ts-node#help-my-types-are-missing).
 
 This can also be enabled with `TS_NODE_FILES=true`.
 

docs/src/content/hardhat-runner/docs/guides/typescript.md

@@ -22,7 +22,7 @@ npx hardhat --network localhost test
 
 If you don't want to manually start and stop Ganache every time, you can use the `hardhat-ganache` plugin.
 
-This plugin creates a network called `ganache`, and automatically starts and stops Ganache before and after running your tests and scripts.
+This plugin creates a network called `ganache`, and automatically starts and stops Ganache before and after running your tests.
 
 To use it, you have to install it with npm