Write your first smart contract in Solidity
Tags: solidity, ethereum, web3, smartcontract
Published: 2021-12-30 23:55:03

---
title: Write your first smart contract in Solidity
published: true
description: Discover the solidity programming language and create and deploy your first smart contract.
tags: solidity, ethereum, web3, smartcontract
//cover_image: https://direct_url_to_image.jpg
---
Few month ago, I started my journey on Ethereum development. I discovered an amazing and very promising ecosystem that is placing the foundation stones of the futur of the internet as we know it.

So today, I decided to write a series of article to get started in this environment that may sound very obscure to a lot of people right now.

## Before we start...

In this article I will cover how to setup a development environment to start working with the Solidity programming language and write a smart contract, then deploy it on a local network. **I will assume you know the basics of programming** (eg: variables, functions, control flows and loops, class...).

## Installing everything you  need:

Firstly, you need to **get a NodeJS environment** set up. If you don’t already have that, you can download NodeJS from the [official website](https://nodejs.org/en/download/) or use your favorite package manager.

Now we can **install Truffle**, an open source tool suite that will allow you to develop, test and deploy your contract.
Use `npm install -g truffle` and you’re all set.

Then, **download Ganache** from the [Truffle website](https://trufflesuite.com/ganache/). This tool will allow you to setup a personal Ethereum blockchain that you can use to run and test your contract.

Finally, you can fire up any IDE, time to code. I would recommend VSCode with the [Solidity plugin](https://github.com/juanfranblanco/vscode-solidity).

## Time to code!

Alright, the first thing to do once you’ve downloaded everything is to init a project. To do so, create a new directory and let truffle do his thing:

```
mkdir fundraiser-contract
cd fundraiser-contract
truffle init
```

Directory and files will be created :

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

We’ll quickly go over these files :

- `contracts/` will contains your solidity sources. It already have a contract in it, called Migration (.sol is the solidity extension). This contract keeps track of migrations and deployment in the network you’re working on.
- `migrations/` contains your smart contracts deployments logic.
- `test/` as you can guess is here for your testing environment.

Good, we’re all set. Now we’re going to create a new contract. Let’s work on a simple fundraiser contract.

So let’s start by creating a new solidity file, say `Fundraiser.sol` in the `contract` directory. Then we’ll add a license, a version directive and create a contract:

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

contract Fundraiser {

}
```

Specifying a license is mandatory in solidity. The pragma statement is used to tell the compiler which Solidity version it should use.

This contract will have few things :

- The owner’s address, which deployed the contract & the one who will get the money collected by the contract.
- An array of the backers, so the owner can personally thank them.

So we will add these as attributes like you would on a regular class:

```solidity
contract Fundraiser {
    address public owner;
    address[] public backers;
}
```

In this example, I’ll set all the variables’ access to public.

To get the owner’s address we will just implement the contract’s constructor and get his address from here. In solidity there is a few global variable that you can access. Here we will use `msg`, which contains the address of the one who calls the functions: `msg.sender`.

Our constructor would look like :

```solidity
constructor() {
    owner = msg.sender;
}
```

Now we need a function accessible to anyone to send some Ether to this contract. We’ll call it `sendMoney` cause that’s what it actually does.

```solidity
function sendMoney() public payable {
    require(msg.value > 0, "No Ether were sent.");
    backers.push(msg.sender);
}
```

The first statement is a `require` call. He's here to check if the condition given as its first argument is true, otherwise, the function will stop its execution and the transaction will be reverted with the error message passed as second argument. Here we want to make sure the caller actually sent some Ether: we check if the function caller *attached* a value: `msg.value`.

Note that the function is marked `public` and `payable` so anyone can call it, and send Ether.

Then, we just add the sender’s address to the backers list.

Next we want to let the owner get it’s freshly raised money. So let’s make a function called `endFundraising` that will collect the money.

```solidity
function endFundraising() public {
    require(msg.sender == owner, "Only the owner is allowed to end the fundraising.");
    payable(owner).transfer(address(this).balance);
}
```

That function will be public but we are going to make sure that the caller (`msg.sender`) is the owner with a `require` statement.
Then, we can just transfer its funds to the owner with the Solidity `transfer` method.

Just for fun, I’ll also add a get balance function:

```solidity
function getBalance() public view returns (uint256) {
    return address(this).balance;
}
```
Every contract has a balance and can hold funds.

And we’re done! You just wrote your first contract 😎.

Here is the full code :

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

contract Fundraiser {
    address public owner;
    address[] public backers;

    constructor() {
        owner = msg.sender;
    }

    function sendMoney() public payable {
        require(msg.value > 0, "No Ether were sent.");
        backers.push(msg.sender);
    }

    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }

    function endFundraising() public {
        require(msg.sender == owner, "Only the owner is allowed to end the fundraising.");
        payable(owner).transfer(address(this).balance);
    }
}
```

As you can see, this contract is quite simple, and I bet you can see a lot of evolutions, such as locking the fundraising once the funds has been transferred, also, wouldn’t it be nice to have a cool web app that would allow any user to send the funds?

## Let’s deploy!

Ok, so the contract should work right? The next step would be to deploy it on your personal network.

And, hey, I can ear you: “Woow!! Are we about to deploy this? Shouldn’t we write tests before and make sure it passes all? What kind of developer is this guy!”...
And you are right. But I keep the testing part for [another post](https://dev.to/kevinmaarek/testing-your-smart-contract-with-truffle-3g6f). This one is getting quite long already - don’t be mad.

Earlier, you installed Ganache. Launch it, click on Quickstart, it will automatically start and setup an Ethereum blockchain on your local network and give you 10 accounts loaded with 100 fake Ether to play with it. Once started, we can prepare our deployment.

Remember that `migration` directory? Create a new JavaScript file called `2_deploy_contracts.js`.

In this file we will write the deployment/migration code for our contract. It’s pretty standard, you can just copy past it:

```solidity
var Fundraiser = artifacts.require("./Fundraiser.sol");

module.exports = function(deployer) {
    deployer.deploy(Fundraiser);
};
```

Now you’re really done. You would just need to type the command `truffle migrate`, in you terminal (make sure you’re in your project’s root).

Now what? [Testing time!](https://dev.to/kevinmaarek/testing-your-smart-contract-with-truffle-3g6f) [Deployment?](https://dev.to/kevinmaarek/deploy-your-smart-contracts-with-truffle-1igl) And, wouldn’t it be nice to test it with a small web app? Yup, that’s what’s next!

Don’t hesitate to comment or contact me via Twitter if you have any question.

Happy coding!