# Developing Smart Contract

we will begin exploring smart contract development, using the Solidity pro‐ gramming language. We will also gain experience with the Truffle framework, which provides tools for deploying and testing our contracts.

Now that we know everything about tools that should use for devloping Smart Contract&#x20;

## Setting Up a New Truffle Project

### 1. **Create a New Directory**

First, we need a directory for our new application. In your terminal, execute the following commands:

```bash
$ mkdir greeter
$ cd greeter
```

### 2. **Initialize the Truffle Project**

Next, initialize a new Truffle project with:

```bash
$ truffle init
```

This command will produce the following output:

```
✔ Preparing to download
✔ Downloading
✔ Cleaning up temporary files
✔ Setting up box
Unbox successful. Sweet!

Commands:
  Compile:        truffle compile
  Migrate:        truffle migrate
  Test contracts: truffle test
```

### 3. **Project Directory Structure**

After initialization, your `greeter` directory will include the following structure:

```
greeter
├── contracts
│   └── Migrations.sol
├── migrations
│   └── 1_initial_migration.js
├── test
└── truffle-config.js
```

#### **Directory Overview**

* **`contracts/`**: Contains Solidity smart contract files. Initially includes `Migrations.sol`.
* **`migrations/`**: Holds migration scripts for deploying contracts. Initially includes `1_initial_migration.js`.
* **`test/`**: Directory for test scripts.
* **`truffle-config.js`**: Configuration file for Truffle.

### 4. **Truffle Commands**

* **Compile Contracts**: To compile all contracts in the `contracts` directory, use:

  ```bash
  $ truffle compile
  ```
* **Deploy Contracts**: To deploy compiled contracts using migration scripts from the `migrations` directory, use:

  ```bash
  $ truffle migrate
  ```
* **Run Tests**: To execute tests located in the `test` directory, use:

  ```bash
  $ truffle test
  ```

### 5. **Configuration**

The `truffle-config.js` file is where you'll configure application-specific settings. Adjust this file as needed for your project's requirements.

***

## Our First Test

To create your first test smart contract for a Truffle project, you can follow these steps. This guide will show you how to create a simple Solidity smart contract and a corresponding test script.

### 1. **Create a Simple Smart Contract**

First, add a new Solidity smart contract to the `contracts` directory. Let's create a basic contract called `Greeter.sol`.

**File: `contracts/Greeter.sol`**

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Greeter {
    string public greeting;

    constructor(string memory _greeting) {
        greeting = _greeting;
    }

    function setGreeting(string memory _greeting) public {
        greeting = _greeting;
    }
}
```

#### Contract Explanation

* **`string public greeting;`**: Declares a public state variable to store the greeting message.
* **`constructor(string memory _greeting)`**: Initializes the greeting message when the contract is deployed.
* **`function setGreeting(string memory _greeting)`**: Allows updating the greeting message.

### 2. **Create a Migration Script**

Create a migration script to deploy the `Greeter` contract. Add this script to the `migrations` directory.

**File: `migrations/2_deploy_greeter.js`**

```javascript
const Greeter = artifacts.require("Greeter");

module.exports = function (deployer) {
  deployer.deploy(Greeter, "Hello, world!");
};
```

#### Script Explanation

* **`artifacts.require("Greeter");`**: Imports the Greeter contract.
* **`deployer.deploy(Greeter, "Hello, world!");`**: Deploys the contract with an initial greeting message.

### 3. **Write a Test Script**

Create a test file in the `test` directory to test the `Greeter` contract.

**File: `test/greeter.js`**

```javascript
const Greeter = artifacts.require("Greeter");

contract("Greeter", accounts => {
  let greeter;

  // Before each test, deploy a new Greeter contract
  beforeEach(async () => {
    greeter = await Greeter.new("Hello, world!");
  });

  it("should initialize with the correct greeting", async () => {
    const greeting = await greeter.greeting();
    assert.equal(greeting, "Hello, world!", "Greeting should be 'Hello, world!'");
  });

  it("should update the greeting", async () => {
    await greeter.setGreeting("Hi there!");
    const greeting = await greeter.greeting();
    assert.equal(greeting, "Hi there!", "Greeting should be 'Hi there!'");
  });
});
```

#### Test Script Explanation

* **`Greeter.new("Hello, world!");`**: Deploys a new instance of the `Greeter` contract with the initial greeting.
* **`it("should initialize with the correct greeting", ...`**: Tests if the contract initializes with the correct greeting.
* **`it("should update the greeting", ...`**: Tests if the greeting can be updated successfully.

### 4. **Run the Tests**

To run the tests, use the following command in your terminal:

```bash
$ truffle test
```

This command will execute the test script and provide output indicating whether the tests passed or failed.
