In the previous tutorial you learned how to create your first smart contract, in this post you will learn how to create a "Wallet" smart contract to which you will be able to send and withdraw Ethereum, of course the contract will be written so that only the owner of the contract will be able to withdraw funds.

What are the keywords: public, external, internal and private ?

You have already learned the keyword public in the previous tutorial "Hello World", it means that the function is public, that is, it can be called both "outside the contract" and inside. Contracts that inherit our contract will have access to such a function.

For example:

uint counter = 0;
    function externalFunction() external  {
        counter++;
        publicFunction();
    }
 
    function publicFunction() public  {
        counter++;
    }

As you can see, the public function can not only be called "outside the smart contract", but also inside it, as in the externalFunction, and just what does this external mean ?

If the function is external, it simply means that it can only be called "outside the smart contract" , just as we called our sayHelloWorld function in the previous tutorial. Contracts that will inherit our contract will have access to the external function.

Two keywords remain : internal and private.

function returnTwoPlusTwo() internal pure returns (uint256)  {
        return 2 + 2;
    }
 
    function returnMsgSender() private view returns (address)  {
        return msg.sender;
    }

Internal is exactly the opposite of external, such a function will not be called "outside the smart contract", but only inside. As with external and public, contracts that inherit such a function will have access to it.

The last is private which means that the function will be visible only in the contract in which it was defined, contracts that inherit our contract will not be able to call it.

Pure vs View

When I showed the functions internal and private, you can see that the words pure and view are added next to these functions. What do they mean ?

When the function is pure, it means that it does not modify or read any data from the blockchain, just like the returnTwoPlusTwo function - it only returns the result of 2+2, it does not load or modify any variable in the smartcontract or blockchain.

Functions with the suffix view, means that the function does not modify data from the blockchain, but instead reads it. For example, the returnMsgSender function reads the value of the msg.sender variable, which represents the address that called the function.

Okay, enough with the theory, let's finally get to work !

How to create "Wallet" smart contract?

First we must, as always, define the version of solidity that we want to use , I will use version 0.8.12, so at the top of the file I type:

pragma solidity 0.8.12;

I am creating a contract called Wallet :

contract Wallet {
   
}

Each wallet has its own owner so will define address on ethreum, who will be the owner of the smart contract. The owner of the smart contract will be the person who will deploy our smart contract.  And we should have a variable thanks to which we can monitor the balance of the smart contract.

contract Wallet {
    address public owner;
    uint public balance;
    constructor() {
        owner = msg.sender;
    }

Let's create a function by which we can transfer funds to the smart contract.

function depositEther() external payable{
        balance += msg.value;
    }

There are two new words in this function : payable and msg.value.

If the function is payable it means that with the function call we can send ethereum to the smart contract, and msg.value is simply the amount of wei sent with the function call.

Now let's create a function by which we can withdraw the sent ethereum, of course, only the owner of the smart contract should be able to do so.

function withdrawEther(uint amount) external{
        require(msg.sender == owner, "Only owner can call this function");
        require(amount <= balance, "Amount exceeds balance");
        balance -= amount;
        payable(owner).transfer(amount);
    }

Require makes the function return an error with the message we specified when the condition given in it fails.

In the function, we had to convert the owner variable from address to address payable, because ethereum can only be sent to addresses with the keyword payable.

Summary

And that's it ! Smart contract is ready ! Go ahead and try to play with it, and if you succeed, even improve it. 

In the next tutorial in the Nextrope Academy series, we will show how to write a simple auction smart contract.