# Prerequisites

Before starting development, ensure that you have the following tools installed:

* **Node.js** (v14 or above)
* **NPM** or **Yarn** (for package management)
* **Solidity Compiler** (`solc`)
* **Truffle** or **Hardhat** (for smart contract development)
* **Phron**  testnet  for local testing
* **Metamask** or any other Ethereum wallet

Here’s a quick guide on installing and setting up the tools you need for Solidity smart contract development, along with code examples for using each tool:

#### 1. **Node.js (v14 or above)**

Node.js is required to run JavaScript-based tools like Truffle and Hardhat.

**Installation:**

* [Download Node.js](https://nodejs.org/) and install it for your operating system.
* Verify installation:

  ```bash
  node -v
  npm -v
  ```

#### 2. **NPM or Yarn (for package management)**

NPM comes with Node.js by default, but you can use Yarn as an alternative.

**Installation (NPM is included with Node.js):**

* Verify installation:

  ```bash
  npm -v
  ```

**Installation (Yarn):**

```bash
npm install -g yarn
yarn -v
```

#### 3. **Solidity Compiler (solc)**

Solidity compiler (`solc`) is needed to compile smart contracts.

**Installation:**

* Using NPM:

  ```bash
  npm install -g solc
  ```
* Verify installation:

  ```bash
  solc --version
  ```

**Example:**

Compiling a contract with `solc`:

```bash
solc --bin --abi SimpleBank.sol -o build/
```

#### 4. **Truffle or Hardhat (for smart contract development)**

Both tools are widely used for developing, testing, and deploying smart contracts.

**Truffle Installation:**

```bash
npm install -g truffle
truffle version
```

**Hardhat Installation:**

```bash
npm install --save-dev hardhat
npx hardhat
```

**Example (Hardhat project setup):**

```bash
npx hardhat compile
npx hardhat run scripts/deploy.js
```

**Example (Truffle project setup):**

```bash
truffle init
truffle compile
truffle migrate
```

#### 5. Get a Phron end point from [Phron.ai.](https://testnet.phron.ai)

#### Nodes and JSON-RPC Endpoints <a href="#nodes-and-json-rpc-endpoints" id="nodes-and-json-rpc-endpoints"></a>

Generally speaking, a JSON-RPC is a remote procedure call (RPC) protocol that utilizes JSON to encode data. For Web3, they refer to the specific JSON-RPCs that DApp developers use to send requests and receive responses from blockchain nodes, making it a crucial element in interactions with smart contracts. They allow frontend user interfaces to seamlessly interact with the smart contracts and provide users with real-time feedback on their actions. They also allow developers to deploy their smart contracts in the first place!

To get a JSON-RPC to communicate with a Phron blockchain, you need to run a node. But that can be expensive, complicated, and a hassle. Fortunately, as long as you have *access* to a node, you can interact with the blockchain. Phron has a handful of free and paid node options. For this tutorial, we will be using the Phron's public node for Phron, but you are encouraged to get your own private endpoint.

```url
https://testnet.phron.ai
```

So now you have a URL. How do you use it? Over `HTTPS`, JSON-RPC requests are `POST` requests that include specific methods for reading and writing data, such as `eth_call` for executing a smart contract function in a read-only manner or `eth_sendRawTransaction` for submitting signed transactions to the network (calls that change the blockchain state). The entire JSON request structure will always have a structure similar to the following:

```json
{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getBalance",
    "params": ["0xf24FF3a9CF04c71Dbc94D0b566f7A27B94566cac", "latest"]
}
```

This example is getting the balance (in DEV on Phron) of the `0xf24FF3a9CF04c71Dbc94D0b566f7A27B94566cac` account. Let's break down the elements:

* `jsonrpc` — the JSON-RPC API version, usually "2.0"
* `id` — an integer value that helps identify a response to a request. Can usually just keep it as \`
* `method` — the specific method to read/write data from/to the blockchain. You can see many of the RPC methods on our docs site
* `params` — an array of the input parameters expected by the specific `method`

There are also additional elements that can be added to JSON-RPC requests, but those four will be seen the most often.

Now, these JSON-RPC requests are pretty useful, but when writing code, it can be a hassle to create a JSON object over and over again. That's why there exist libraries that help abstract and facilitate the usage of these requests. Phron provides documentation on many libraries, and the one that we will be using in this tutorial is Ethers.js. Just understand that whenever we interact with the blockchain through the Ethers.js package, we're really using JSON-RPC!

#### 6. **Metamask or Other Ethereum Wallets**

Metamask is a browser-based Ethereum wallet for interacting with decentralized applications (dApps).

**Installation:**

* [Download Metamask](https://metamask.io/) and install the browser extension.