This section will teach us how to create a new project. It will require us to explore the code and the Solidity syntax. Deploying the project will help us understand how easy it is to transform this project into a better payment application. To get a better understanding of the concept, we are going to take a look at some specifics on bug fixing and also learn to debug smart contracts and some function applications.

To begin, we need to create a new folder. For convention's sake, let's name this my_first_project.

The immediate next step would be to run Truffle. The following command is used for this:

C:\WINDOWS\system32>truffle

The output of the command should be as follows:

This displays the list of commands that can be used for various processes for Truffle. The Truffle init command allows us to initialize a new Truffle project.

Throughout the...

We will now be deploying the application that we created in the previous section. We will do so by starting a development blockchain, configuring our deployment, deploying our smart contracts, and building the application.

Firstly, we are going to want to run our development blockchain. This can be done by typing ganache-cli in the terminal window. Your screen will look as follows:

Make sure you jot down or remember the localhost port number. It is of importance, as you will be connecting to it in the later stages of this project. Ganache-cli generates 10 available accounts and then the corresponding private keys. These private keys are used to encrypt...

This section will help us understand the Solidity syntax. We will explore the Solidity and JavaScript codes to understand our project in depth. This will also give us the power to alter the code to customize it to our needs.

For understanding the syntax, let's take a look at the Solidity file MetaCoin.sol. The following screenshot will act as a guide so that we understand every line of code:

As you can see, every Solidity file begins with the definition of the Solidity version that you are currently using. In this case, that would be 0.4.17. This is immediately followed by the importing of the conversion library (commonly known as...

This section tells you how to go about bug fixing and debugging your code. Usually, the code will be debugged in the developer console which is similar to developing regular JavaScript code. If there is an error present in the JavaScript code, you could easily rectify it on the developer console. However, if the bug is in your smart contract, you are going to want to go a bit deeper. How are you going to debug your smart contract once it is live? Well, you cannot—not locally at least. What if somebody finds a bug? You need to find out where it came from. For these very reasons, we can use remix.ethereum.org and etherscan.io.

The modified version of the MetaCoin Solidity file found at remix.ethereum.org is as follows:

You can create this file yourself by clicking the little plus icon in the top-left corner and giving it a name of...

This section will focus on us improving our code. This will include adding functionalities such as depositing ether, gaining tokens, and withdrawing ether in exchange of tokens and also a creator fee.

We will work on the same code that was used for the previous section and continue to build on it.

As we do not want to give away free tokens in exchange for deposited ether, we will eliminate the following line of code completely:

function MetaCoin() public {
    balances[tx.origin] = 10000;
  }

We begin by setting a creator. To do this, we will need to define an address creator and a creatorFee as follows:

contract MetaCoin {
  mapping (address => uint) balances;
  address creator;
  uint creatorFee = 1;
  uint collectedFees = 0;
  
  uint conversionRate = 5;

  uint CURRENCY_MULTIPLIER = 10**18;

The collectedFees is what one might...

In this chapter, we took a look at how to create an Ethereum based application. We also deployed and tested the same projects. We then delved into the Solidity syntax which isn't only vast but is also extensive. JavaScript codes were also looked into. We learned how to fix bugs using our own systems as well as externally. In the end, we finally converted our project into a payment application.

The next chapter focuses on the concepts of creating our own tokens. We will take closer look at ICO's and also at handling our own token transactions.