Introduction

In this tutorial, we will guide you through the basics of developing a smart contract. We will cover the design phase, code writing, and testing of the smart contract. By the end of this guide, you will have a solid understanding of how to create your own smart contracts.

You will learn how to:
- Write a smart contract
- Deploy the contract on a blockchain
- Interact with the contract

Prerequisites:
- Basic understanding of Blockchain technology
- Familiarity with Solidity programming language

Step-by-Step Guide

Designing the Contract

Before we jump into coding, it's important to plan out our smart contract's design. A good smart contract should be efficient, secure, and easy to understand. We need to identify what the contract will do, what data it needs, and how users will interact with it.

Writing the Code

Now that we have a plan, it's time to start writing the code. We will use Solidity, a statically typed, contract-oriented programming language. Solidity is used for implementing smart contracts on various blockchain platforms.

Testing the Contract

After we've written our smart contract, we need to test it thoroughly. This includes testing for functionality, security, and performance.

Code Examples

Let's consider a simple contract for a decentralized voting system. This contract will allow voters to cast their votes on options provided.

// Declare the version of Solidity compiler this code will be compiled with
pragma solidity ^0.5.16;

// Start of contract
contract Voting {

    // Declare a new complex type to hold the option and vote count
    struct Choice {
        uint voteCount; // number of accumulated votes
        string name;    // name of the option
    }

    // Declare a mapping to link each voter's address to a voted flag
    mapping(address => bool) public voted;

    // Declare an array to store all choices
    Choice[] public choices;

    // Function to add a new choice
    function addChoice(string memory _name) public {
        choices.push(Choice(0, _name));
    }

    // Function to vote for a choice
    function vote(uint _choiceId) public {
        // Check if the voter has not voted before
        require(!voted[msg.sender], "You have already voted!");

        // Record that the voter has voted
        voted[msg.sender] = true;

        // Increase the choice's vote Count
        choices[_choiceId].voteCount += 1;
    }
}

This contract first declares a new type Choice to hold an option and its number of votes. It then declares a mapping voted to remember if an address has voted or not, and an array choices to store all the options. Two functions are declared, addChoice and vote, to add a new option and to vote for an option respectively.

Summary

In this tutorial, we covered how to design, write, and test a smart contract. You learned how to define and use complex types, mappings, and arrays in Solidity. You also learned how to write functions and use the require statement to check for conditions.

For further learning, you can explore how to deploy your smart contract on a test network, and how to interact with it using web3.js library.

Practice Exercises

1. Modify the contract to limit the number of choices that can be added.
2. Modify the contract to allow the creator of the contract to close the voting.

Solutions

1. To limit the number of choices, you can add a state variable to keep track of the number of choices. Then, in addChoice function, check if the limit is reached before adding a new choice.
2. To allow the creator to close the voting, you can add a state variable isOpen to indicate if the voting is open or not. Then, add a function closeVoting that can only be called by the creator to set isOpen to false. In vote function, check if isOpen is true before allowing a vote.

Remember, the key to mastering smart contract development is practice. Try to build different types of contracts and experiment with the Solidity language. Happy coding!