Quick refresher, what is Solidity?

Solidity is a high-level programming language designed for writing smart contracts on blockchain platforms, primarily Ethereum. It is statically typed and designed to target the Ethereum Virtual Machine (EVM). Solidity has syntax similar to JavaScript, which makes it relatively approachable for developers familiar with JavaScript or similar languages. It focuses on contracts, which are fundamental building blocks of Ethereum. Each contract contains code (functions) and data (state). Like other programming languages, Solidity programming also has variables, functions, classes, arithmetic operations, string manipulation, and many other concepts.

Setting up our environment

For a solidity project, you need Node.js and npm (Node Package Manager) or Yarn installed on your system. For Windows users, it is advisable to activate the Windows SubLinux System (WSL). You can follow this tutorial to get started. After installing WSL, go to the extension tab in your VSCode and search Remote Development, and install it. You can also use Powershell if you want though you might run into some errors.

Follow these steps to set up your environment:

1. Download and Install Node.js and npm:

   • Go to the Node.js official website and download the latest stable version.

   • Follow the installation instructions for your operating system.

   • Confirm you have properly installed Node by running node --version . You should get something like this v20.11.0

2. Install Yarn (alternative to npm):

   Nodejs comes with a feature called corepack. To install yarn, run corepack enable . If you are using an older Node version (<16.10), you run npm i -g corepack instead.

3. Install git

   if you don't already have git installed, visit git to install it. You'll know you did it right if you can run git --version and you see a response like git version x.x.x

Starting a project

• Make a directory where you want your project so mkdir MyProject and then cd into it, cd MyProject. Open up the directory in your VSCode using code .

• In the terminal, run npm init or yarn init to initial a new project. This will add a package.json file to the directory.

• Next, run yarn add --dev hardhat or npm install --save-dev hardhat to start a Hardhat project in our directory.

• Quick Note:

  Hardhat is a development environment for smart contracts/Ethereum software. It consists of different components for editing, compiling, debugging, and deploying your smart contracts and dApps, all of which work together to create a complete development environment. It makes our work easier and faster. There are others like Foundry, and Brownie, which you can explore based on your preferences. Foundry is written in Rust and focuses on performance, while Brownie is Python-based, suitable for those comfortable with Python. For this tutorial, we will use Hardhat due to its extensive documentation and support.

  Keep in mind, Hardhat uses Javascript or Typescript so you need knowledge of them.

• After running the above commands, you should get something like this

  

• You can pick a Javascript project, a Typescript project if that is what you are familiar with, or an empty config file that you will buy from scratch. I'll pick the Javascript project.

• Follow the instructions on the screen and you should have something like this finally

• 

  Now you can go ahead and create your smart contract, deploy it, and test it too.

Understanding the Folder Structure

Let's have a quick overview of our project folder.

• .yarn: not something you should bothered with but necessary for hardhat to run so leave it as is.

• contracts: this folder will contain all the smart contract files you will create, in our example, Lock.sol. Now, it is not compulsory to have it all in a folder but it gives a cleaner view

• Ignition: This folder will contain your deployment scripts. Also not compulsory

• Test: this will contain all the test files for your contracts. Unit test, fuzz test, etc, should all be in here.

• .gitignore: this will contain files that you do not want to expose should you push your project to GitHub. Files like the .env file for your environmental variables like API key, deployment files, node modules, artifacts, etc.

• hardhat.config.js: this contains configurations specific to your project like blockchain networks that you will use, the solidity version, etc.

• README.md: The file guides users in navigating the project and should contain key information such as the project title, description, table of contents, technologies used, requirements, installation and usage instructions, contribution guidelines, and more.

Conclusion

Congratulations! You've successfully set up your development environment, initialized a new Solidity project, and learned about the key components of your project folder. With this solid foundation, you're now equipped to dive deeper into writing and deploying smart contracts on the Ethereum blockchain. Remember, practice is key, so keep experimenting with different features and functionalities as you continue your journey into the world of blockchain development. Happy coding!

A tiny mistake can lead to drastic losses for both users and projects using smart contracts. This is why testing your contract before deployment is very important to avoid these cases.

Unit Testings

There is a range of testing techniques, from simple manual verifications (interacting with our contract in the terminal console) to complex end-to-end setups, all of them useful in their own way.

In smart contract development, unit testing has proven to be very useful. These tests are simple to write and quick to run, and let you add features and fix bugs in your code with confidence and ease. This testing consists of multiple small, focused tests, which each check a small part of your contract for correctness.

They can often be expressed in single sentences, such as 'the admin is able to pause the contract', 'transferring tokens emits an event' or 'non-admins cannot mint new tokens', followed by lines of codes to check if these actions actually happen without issues. An example can be seen below:

// test/Load.test.js
// Add dependencies
const { expect } = require('chai');

// Start test block
describe('Load', function () {
  before(async function () {
    this.Load = await ethers.getContractFactory('Load');
  });

  beforeEach(async function () {
    this.load = await this.Load.deploy();
    await this.load.deployed();
  });

  // Test case
  it('retrieve returns a value previously stored', async function () {
    // Store a value
    await this.load.store(39);

    // Test if the returned value is the same one
    // Note that we need to use strings to compare the 256 bit integers
    expect((await this.load.retrieve()).toString()).to.equal('42');
  });
});

Setting up Testing Environment

To run this test, we need a testing environment. Using mainnet is expensive and testnet can be very slow. So a local blockchain is very useful in this case. Hardhat, an ethereum development environment, has a local blockchain that can be used. You just need to keep it running in your terminal.

Another important component is Chai. Chai is an assertion library that you can pair with javascript testing framework. This where we get keywords like 'expect', and 'assert' for testing.

You create a file named after the contract you want to test. In the example above, Load.sol is the contract we are testing, so our test file will be Load.test.js.

Finally to run this test, we use command 'yarn hardhat test' or 'npx hardhat test'. If it passes we should get this in terminal:

yarn hardhat test

Congratulations! You just successfully ran a unit test.

Wrap up

Now depending on how big your contract file is, you can continue taking it in bits till you take care of everything (advisable), you can also run more complex tests using Openzeppelin Tests Helper zeppelin Tests Helper. This helps you to capture parts of your code that might not get properly tested in unit testing.

There are of course other testing options available. You can check those out and use them to complement your unit testings for a more secured contract.

Now you know what unit testing is and how to go about it. Get testing!!

Like any other programming language, you work with variables. When declaring a variable in solidity, you need to state the data type and the visibility before the variable name. This is to help prevent unnecessary type conversion and to help the compiler know how much space to allocate to each variable. so it looks like this:

// Signed integer (int) and unsigned integer (uint) 
    int256 public number = 10;
    uint256 public number = 10;

 //Strings
    string public greeting = "Hello, World!";

• int256, uint256, string - data types

• public - visibility

• number, greetings - variable name

Signed integers represent both negative and positive integers and unsigned integers only represent non-negative integers (zero and positive numbers).

Visibilities

Visibilities attached to variables determine how those variables can be accessed or modified by other parts of the contract or by external contracts. The four visibility levels are public, private, eternal and internal.

• A public contract can be accessed outside the contract, typically using getter functions but it cannot be modified directly from outside the contract.

• A private variable can only be accessed and modified within the same contract where they are declared. They are not visible to external contracts or even derived contracts.

• External variables are similar to public variables in that they can be accessed from outside the contract, but they cannot be read directly within the contract. They are typically used for function parameters to prevent direct access to the variable's value within the contract.

• Internal variables are visible to the contract that declares them and any contracts derived from it (i.e., contracts that inherit from it). They cannot be accessed from external contracts.

Data Types​

Solidity supports various data types, such as:

• Boolean: bool - true or false

• Integer: int (signed) and uint (unsigned)

• Address: address

• String: string - letters

• Bytes: bytes (dynamic-size) and bytes32 (fixed-size)

• Arrays: dynamic-size or fixed-size and can be declared with other types.

• Structs: struct - user-defined types that group multiple variables of possibly different types under a single name.

• Enums: enum - user-defined type with a finite set of possible values

• Mapping: mapping - an array of key-value pairs

Here are implementations for each data type:

    // Boolean
    bool public isCompleted = false;

    // Integer (signed and unsigned)
    int256 public number = -10;
    uint256 public number = 10;

    // Address
    address public userAddress = 0x742d35Cc6634C0532925a3b844Bc454e4438f44e;

    // String
    string public greeting = "Hello, World!";

    // Bytes (dynamic-size and fixed-size)
    bytes public dynamicBytes = "hello, solidity";
    bytes32 public fixedBytes = "hello, solidity";

    // Arrays (dynamic-size and fixed-size)
    uint[] public dynamicArray = [1, 2, 3];
    uint[5] public fixedArray = [1, 2, 3, 4, 5];

    address[] public dynamicAddressArray = [0xd41d1744871f42Bb724D777A2d0Bf53FB43a0040, 0x1f514ae9834aEAF6c2c3eb6D20E27e865F419010];
    address[3] public fixedAddressArray = [0xC90cd0D820D6dc447B3cD9545185B046873786A6, 0x401997E856CE51e0D4A8f26ce64952313BEA0E25, 0x221d3b9821f3Cc49B42E7dd487E2a6d1b3ed0E05];

    bool[] public dynamicBoolArray = [true, false, true];
    bool[2] public fixedBoolArray = [true, false];

    // Struct
    struct Person {
        string name;
        uint age;
    }
    Person public person = Person("Alice", 30);

    // Enums
    enum Status { Open, Closed, Pending }
    Status public currentStatus = Status.Open;
    Status public nextStatus = Status.Closed;
    Status public previousStatus = Status.Pending;

    // Mapping
    mapping(address => uint) public balances;

There are a lot more I didn't touch on but hope this helps with readability the next time you come across a solidity code block. Have fun and enjoy!!