DEV Community: Tchisom17

Understanding Ether Transfers in Solidity: send, transfer, and call

Tchisom17 — Fri, 30 Aug 2024 00:54:37 +0000

Introduction

Hello! I am back with an article on Ether transfers in solidity. Being a developer of Ethereum smart contracts, knowing how to handle the movement of Ether in a safe and optimized way should be a must-have. We are going to talk about what Ether transfers are, some use cases of them and a little comparison between them.

Let's start with the basics. If you are already familiar with the basics you can skip to 2.

1. The Basics of Ether Transfers In Solidity
What is ether? Ether(ETH) is Ethereum's native cryptocurrency. It is used to pay transaction fees.
There might be plenty of cases when you would want to transfer Ether within or between smart contracts. For instance, you might want to:

Pay for a service within a dApp.
Give rewards to users.
Execute a funding round in a decentralized finance (DeFi) project.

For each case, the best way of sending Ether will affect how your contract works and how secure it is.

So far, Solidity provides three ways to transfer Ether: send, transfer, and call. Since they could seem exchangeable, their differences may have huge consequences.

2. send: The send function is one of the most straightforward ways to transfer Ether. As such, it is quite easy to use and works fine to complete the job. It does have a couple of limitations: for example, it only forwards 2300 gas, which is enough to cover simple operations but does not suffice for more complex tasks. It also returns false in case of failure, which would mean you'd have to handle errors yourself.

bool success = recipient.send(1 ether);
if (!success) {
    // Handle failure, such as logging or triggering an alert
}

Use Cases: send might be appropriate when:

You’re sending Ether to an external account and want to avoid gas-related failures.
You want to ensure that your contract continues executing even if the transfer fails.

However, due to its limitations, it is less used today.

3. transfer: This was in the past the easiest and safest way of transferring Ethers before Solidity 0.6.0 and used built-in safety. Like the send function, this also has a gas limit of 2300 but instead of returning false in case of failure, this throws an error and reverts the transaction.

function transfer(address payable _to) public payable {
     _to.transfer(msg.value); // Automatically reverts on failure
}

Use Case: It is ideal for simple contracts where you need to ensure the transaction either fully succeeds or fails.

4. call: This offers the most control and flexibility compared to the above two because it allows a user to set the amount of gas to be used. In case the amount of gas is not set, it forwards all the remaining gas to the transaction. It is the recommended method of transferring Ether from Solidity 0.6.0 onward and returns a boolean which would require you to handle errors manually. Another caveat to take note of is that it is more prone to reentrancy attacks compared to the other two functions.

NOTE: A reentrancy attack happens when the contract allows a function to be called again before the previous call finishes.

function sendViaCall(address payable _to) public payable {
    (bool sent, bytes memory data) = _to.call{value: msg.value}(""); // Returns false on failure
    require(sent, "Failed to send Ether");
}

Use Case: Best for complex interactions where you need to control the gas or when dealing with contracts that require more gas.

5. Comparison and Best Practices

Security: transfer and send are safer by default due to their limited gas stipend. call requires careful use to prevent vulnerabilities.
Gas Consumption: Use send or transfer for simpler tasks; reserve call for more complex scenarios.
Failure Handling: Use transfer for guaranteed atomicity. Opt for send or call if you need more control over failure handling.

Conclusion

Your smart contract in Solidity possesses one of several methods for Ether transfer, according to your needs. You may be using transfer for simplicity and security, or you use call for more power and flexibility. Send allows you to handle transfer failures manually. Keep the trade-offs among these three transfer methods in mind when you build secure and efficient Ethereum smart contracts.

Start today by reviewing your past contracts, and double-check that you are using the best transfer method for a given scenario. Sometimes those small changes can end up making so much more of a difference in how secure and robust your dApps are.

If you found this post helpful, please like and comment below. Your feedback is valuable and informs others in the community!

Understanding ERC-20: The Standard for Fungible Tokens on Ethereum

Tchisom17 — Tue, 27 Aug 2024 10:41:33 +0000

Introduction

In the consistently advancing universe of blockchain technology, Ethereum has arisen as one of the most distinguished platforms for decentralized applications (dApps) and smart contracts. A vital part of Ethereum's environment is the idea of tokens — digital assets that address different utilities or values inside a blockchain network.

Among the numerous symbolic guidelines accessible on Ethereum, ERC-20 has turned into the most broadly embraced and perceived norm for making fungible tokens. These tokens are indistinguishable in value and can be handily traded, making them the foundation of many decentralized applications and monetary systems. In this article, we'll dive into what ERC-20 is, the reason it makes a difference, and how you can make your own ERC-20 token on Ethereum.

What is ERC-20?

ERC-20, short for Ethereum Request for Comment 20, is a specialized standard utilized for making and giving smart contracts on the Ethereum blockchain. These smart contracts are liable for overseeing tokens — digital assets representing anything from currency to loyalty points.

Fabian Vogelsteller proposed ERC-20 in November 2015 and it immediately turned into the norm for making fungible tokens on Ethereum. The standard blueprints are a bunch of rules and functions that a token contract should execute, guaranteeing that all ERC-20 tokens act typically and can be integrated with different dApps, wallets, and exchanges.

The purpose of ERC-20 is to create a standard set of rules for creating tokens. This standard ensures that any ERC-20 token can easily interface with other smart contracts, DAPPs and decentralized exchanges on the Ethereum blockchain.

Key Features of ERC-20

Fungibility
The fungibility of ERC-20 tokens is one notable feature. Then there are fungible tokens, which have no unique properties and characteristics meaning one token is the same as any other. This makes ERC-20 tokens best suited for currency-like assets where every unit should be equal and exchangeable.

Interoperability
This is a capability that the creators had in mind when they were creating ERC-20s, hoping for these tokens to be interoperable with as long of a list of dApps and wallets and exchanges as possible. These functions allow for this interoperability, and they define the standard that ERC-20 tokens are meant to meet. As a result, any ERC-20 tokens compatible app can easily add new Tokens without major development effort.

Standardized Functions
Each contract included in the ERC-20 standard specifies a core set of functions that all contracts are required to provide. Such functions are basic functions such as transferring tokens and querying balances and limiting how many times third parties can be allowed to utilize the tokens owned by the particular owner. Such standardization facilitates the influx of new tokens and interoperability among these new token services and the rest of the Ethereum ecosystem.

The Core Functions of ERC-20

The ERC-20 standard outlines six core elements without which no token contract will be created. These functions make up the structure upon which the ERC-20 tokens rest regarding operation and integration with contracts and applications.

totalSupply(): It indicates the number of tokens that have been created and are stored in the blockchain. If a smart contract implements this function, it declares how many tokens, in total, can be issued for free or sold to investors.

    /**
     * @dev Returns the value of tokens in existence.
     */

    function totalSupply() external view returns (uint256);

balanceOf(address _owner): It explains how many tokens a given address is holding. It is a function that is used in checking the balances of any owned Ethereum tokens.

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

transfer(address _to, uint256 _value): This function enables the owner of the token to send a given amount of the token to another address. It is the simplest of all possible functions which allows transferring the tokens to and excluding the knees of patients.

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

approve(address _spender, uint256 _value): This function enables a token owner to approve a third party (the spender) for the withdrawal of a certain number of tokens from their account which includes but is not limited to the user’s account. This often happens within the decentralized finance applications where a smart contract has to move the tokens on the user’s behalf.

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

allowance(address _owner, address _spender): This method allows a spender receiving the amount to know the total amount yet to be withdrawn from the owner's account. It works hand in hand with the approve() method in giving authorizations for tokes to be used.

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

transferFrom(address _from, address _to, uint256 _value): This function allows a third party (the spender) to transfer tokens on behalf of the token owner subject to the condition that there is reasonable allowance. This feature is critical in the functioning of smart contacts to enable them to integrate token management within intricate operations.

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);

Creating an ERC-20 Token

Creation of an ERC-20 token involves writing a smart contract for the token in the Ethereum language Solidity. Below, we’ll walk through the basic steps to create a simple ERC-20 token.

Setting Up the Development Environment
Before writing the contract, you will be required to prepare a development environment. Some known tools are:

Remix IDE: An Integrated Development Environment which runs in a web browser to create, analyze, and launch the development of periodic smart contracts.
Truffle Suite: Ethereum's Development Framework comes with an array of tools that allow for the development, testing, and deployment of decentralized applications.
Hardhat: More control over network simulation and contract tests is accessible with this adaptable development environment.

Writing the Solidity Contract
Now that the environment is set up, it’s time to write the code for your ERC-20 token. Below gives the reader a simple understanding of an ERC-20 contract:

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor() ERC20("MyToken", "MTK") {
        _mint(msg.sender, 1000000 * 10 ** decimals());
    }
}

In this contract:

ERC20("MyToken", "MTK"): This parameter includes the name of the token and its symbol.
_mint(msg.sender, 1000000 * 10 ** decimals()): The address that is registered as the creator of the address should receive exactly 1,000,000 tokens.

Deploying the Contract on Ethereum
Having prepared and written the said contract, it’s possible to deploy it into the Ethereum Blockchain. This can be done with the use of tools like Remix, Truffle, or Hardhat. After which, the token will be operational on the Ethereum platform and it will be available for trading or using it within dApps.

Conclusion

The adoption of the ERC-20 standard by developers when creating a fungible token has indisputably marked the legitimation of this crucial subsystem of Ethereum. The stability, popularity and cross-functional nature of the token is a worthwhile factor for developers more so those who are looking to launch new tokens. During this phase, whether it is a new cryptocurrency, a DeFi platform, or utility tokens for your dApp there is a great emphasis on the loss-free compliance and the use of the ERC-20 standard.

The guide in several other newspapers, the Safe ERC20 defined as: this new implementation will want to easily create a more secure fast page application using the guidelines oriented to the core features of the ERC20 safe multi-coin.

So if you are eager to create your own ERC-20 token or you want to expand your knowledge of Ethereum development, go straight to Solidity and try creating your tokens. Please share your ideas, questions, or comments in the comments section below. Happy coding!

How To Deploy An Azure Function App Using Visual Studio

Tchisom17 — Sat, 10 Jun 2023 15:45:03 +0000

Hello there! I will be walking you through how to create an Azure Function App and publish to Azure portal using Visual Studio.

Also, we would be creating and deploying a calculator app. So, sit back, follow through and enjoy the learning journey.

Prerequisites

Visual Studio Community with .Net Development workload (Click here to download).
Azure Account (Click here to register if you don't have an account or proceed to sign in).
Note: The interface of my Visual Studio might be different from yours as I am on a Mac, but the processes are almost the same with only slight difference.

Now that you have all the requirements, let's proceed to creating our function app.

Step 1: Log in to Azure Portal, Search for "Function App" in the search box and click on "Create".

Step 2a: Fill out the necessary fields.
Note: Steps 2a and 2b can be completed in one step. I divided mine into two in order to capture the whole fields.

For resource group, You can create a new resource group by clicking the "create new" or you can choose a previously created resource group. I called mine "my resources". You can choose to call yours whatever name you desire.
"Function App Name" is also random. I chose "Blog-Calculator-App".
Select "Code" as against "Container Image".
Select ".Net" as your runtime stack. It will automatically choose the version and region for you.

Step 2b: Choose your preferred operating system and use the default hosting option. Then click on "Review + Create".
At this point, you may want to grab a pop corn while it finishes deploying.

Step 3a: Open Visual Studio and click on "New".

Step 3b: Click on "General" under "Cloud". Then select "Azure Functions" and click on "Continue".

Step 3c: On the side side pane, select "Http trigger", give your function app a name and click on "Continue".
The reason for choosing "Http trigger" is so that we could test it over the web or browser.

Step 3d: Go ahead and click on "Create".

Step 4: Replace the codes from line 13 to line 34 with this:
public static class Sum
{
[FunctionName("Sum")]
public static async Task Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
int x = int.Parse(req.Query["x"]);
int y = int.Parse(req.Query["y"]);
int result = x + y;
return new OkObjectResult(result);
}
}

Step 5: Click on "Build" at the top of your IDE. Then click on "Build Solution".
Ensure your application builds successfully.

Step 6: Click on "Build" and then "Publish to Azure". Then Proceed to sign in with your Azure credentials.

Step 7: You would see a list of your resource groups and services. Choose the one that matches the Function App name you created on Azure Portal. Then click on "Publish".

Wait for it to finish publishing. If it's successful you should see something like this in your browser

Step 9: Go back to Azure Portal and click on the function app you created earlier. On the left pane click on "Functions".
You should be able to see the function we just published with the name "Sum".

Step 10: Click on Sum, then click on "Get Function Url". Copy the Url.

Step 11: Paste the Url in any browser of your choice, append the values of x and y to the Url, click enter to know if the sum function is working perfectly.
Notice how I appended the values of x and y to the Url.

There you have it. You have successfully published a Function App using Visual Studio to Azure portal, and you have tested it using http.

Connect with me
LinkedIn: https://www.linkedin.com/in/chisom-amadi/
GitHub: https://github.com/tchisom17

Installing Linux(Ubuntu) on A Virtual Machine Using VMWare on Mac

Tchisom17 — Sat, 27 May 2023 11:08:20 +0000

Linux is one of the major operating systems and is heavily used in organisations all around the world.

In this blog post, I would walk you through how to create a Linux environment on your macOS using VMWare. I will be working with the following technologies:

Ubuntu 22.04 (Download Ubuntu 22.04 from here)
VMWare Fusion (Download VMWare Fusion from here)

Note: You should create an account before downloading the VMWare Fusion so as to receive a license key, but if you already have a license key, you can download without creating an account.

After downloading the VMWare Fusion, make sure to install it.

Now that we have all the requirements, let's proceed to install ubuntu on our computer.

Steps to Installing Ubuntu in VMWare Fusion

Click on LaunchPad, and on the search bar type "VMWare Fusion". Click on it and wait for it to open. Then double-click on Install from disc or image.

Choose the Ubuntu operating system or just drag and drop it in the VMWare Fusion. Then click on Continue.

Next, you fill in the fields and click on Continue.

Remember, all fields are required in order to proceed to the next stage.

Next, Click on Finish. You will get a dialogue box requesting you to save your Virtual Machine. Click on Save.

Click on Virtual Machine at the top of your screen, and the click Shut Down.

Next, click on the spanner icon.

An interface should appear. Click on Processors & Memory.

Increase the Processor to ensure the Vm works fine and does not lag.

The default Processor is the "2 processor cores" but I am going with "4 processor cores" because the default processor makes my computer slow. You can choose the one that works best for your computer. I strongly recommend the "4 processor cores".

Next, you need to restart the Virtual Machine that you shut down by clicking the play button and wait for it to install.

After installing, next is to select your preferred language and click Continue.

Next is to choose your desired updates and softwares. Then click Continue.

It is important to note that you can choose options that are different from mine. In fact the default options are different from how the options I decided to go with.

Check the Erase disk and Install Ubuntu and click on Install now.

A dialogue box would appear. Click on Continue.

It should automatically get your location. Then click Continue.

Fill the fields and click on Continue.

Wait for it to finish copying and retrieving files. This process lasts a few minutes.

Click on Restart Now.

Upon restarting, Click on the user and input your password then hit enter.

You can skip the settings in the subsequent pages till you get to the last one, then click Done.

Voila! You have successfully installed Ubuntu.

Connect with me
LinkedIn: https://www.linkedin.com/in/chisom-amadi/
GitHub: https://github.com/tchisom17

How to Create a Virtual Machine on MacOS

Tchisom17 — Fri, 19 May 2023 19:58:14 +0000

Introduction

In this blog, I will walk you through the step-by-step process of how to set up a virtual machine on a macOS.

First off, What is a Virtual Machine?
A Virtual Machine (VM) is a software emulation of a physical computer. It includes virtual processors, memory, storage and networking. In other words, It has everything a physical computer would have.
Now that you know what a Virtual Machine is, let'

Steps to Create A Virtual Machine

Log in to Azure Portal or Sign up here if you don't have an account.
This is how your Azure Portal would look like once logged in.

You can either click on the search bar and search for virtual machines or click on Create a resource

Fill the form that pops up. Let's start with creating a resource group by clicking on the Create new
The name of a resource group can be random, so I decided to call mine Practice.

Then proceed to give the Virtual Machine a name, select a region, Choose an Image and leave the other fields with the default recommendation.

I named my virtual machine as pracvm, but you can name yours anything. Next is to set a username and password You can optionally configure disks, network, etc. on the next pages. Proceed to click on Review + create.

The Review + create tab should open with some information about your virtual machine and a green checkmark. Proceed and click Create

Wait for it to finish deploying and your virtual machine would be created.

Voila, your VM has been created! Click on Go to resource

Next, go to app store and install Microsoft Remote Desktop
I already have it installed that's why mine is showing OPEN. If you don't have it installed it's going to show GET. I will go ahead and click on OPEN.
You should have a similar interface but yours should be empty. Click on the plus button and then Add PC.

A dialogue box should appear. Fill the box and click on Add button.

To get the PC name, go to virtual machine you created earlier, copy the Public IP address and paste it.
Friendly name is optional. You can give yours any name.

Next, Double click on the newly added PC. It should prompt you to enter a username and password.
The username and password should be the same you used in creating your virtual machine. Then click on Continue.

Congrats! You did it.

Always delete any resources created on Azure whenever you are completely done with them to save cost.

I hope you enjoyed the journey as much as I did.

Connect with me
LinkedIn: https://www.linkedin.com/in/chisom-amadi/
GitHub: https://github.com/tchisom17