DEV Community: Sunington

Understanding Mapping in Solidity (set, get, delete, iterate and nested mapping)

Sunington — Mon, 26 Dec 2022 19:21:03 +0000

What is Mapping?
Creating a Mapping
Set, Add, Get, Updat and Delete Mapping
Nested Mapping
Iterable Mappings

What is Mapping?

Mapping in solidity is like a hash table containing a Key Type and Value Type used to store data. Mapping are used to map or associate a keytype to a value type.

Syntax : Mapping(KeyType => ValueType) ;

The KeyType can be any built-in value types, strings or bytes. The ValueType can be any type including complex types like structs, mappings or arrays.

Key Considerations

Mapping can only have a data location of storage and thus are allowed for state variable.
Mappings can be marked public
Mappings are not iterable except you implement a data structure then iterate over that.

Creating a Mapping

To create a mapping in solidity the keytype and the Value type sould be specified.

Code Sample : In the code sample below, the contract name mappingExample defines a contract, a mapping of keytype, address and value type uint is created.

How to Set, Get, Delete and Update mapping.

1) Setting or Adding Value

We can set or add value to a mapping.

Code sample : In the code sample below, we created a contract called mappingExample, a mapping called myMapping is defined and values are added to the mapping through the function addMapping().

The address is set to msg.sender and its mapping value type to uint, of values from "input".

If "input" = 123; then myMapping[msg.sender] = 123;

#note : If the value for the mapping was not set it will always return the default value.

2) Getting Value

We have added values to the mapping. Let's create function to retrieve the values from the mapping .

#note : If the value of mapping was not set it always return 0, the default value for uint.

Code Sample : In the code sample below, a mapping myMapping is defined. We get the mapping value from the mapping through the function getMapping() using myMapping[msg.sender]

3) Deleting Value

We can delete or remove the value of a mapping, resetting it to the default value, 0.

Code Sample : In the code sample below, a mapping myMapping is defined, we delete values from the mapping through deleteMapping() using delete myMapping[msg.sender]

Nested Mapping

Nested mapping is a mapping within another mapping; that's a mapping that maps to another mapping and we access the inner mapping through the outer mapping.

Syntax : mapping(address => mapping(address => uint)) name;

Code Sample : In the code sample below, a nested outer mapping myNestedMapping is created mapping from address to another mapping, mapping to a uint. We add value to the mapping through the function addNestedMapping(), get value of the nested mapping through the function getNestedMapping() and also delete value with the function deleteNestedMapping()

Iterable Mapping

We cannot iterate over mapping, meaning that their keys cannot be enumerated.

However, it's possible to iterate mapping only if we implement a data structure on top of them and iterate over that.

Access the code here Solidity By Example

Example : Creating a mapping that transfers and approves transactions.

In the code sample below, a contract mappingExample is created and a mapping _balances and nested mapping _allowances, mapping from address to uint are created respectively.

Copy code below to run on your server.

contract MappingExample {
mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowances;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        require(_allowances[sender][msg.sender] >= amount, "ERC20: Allowance not high enough.");
        _allowances[sender][msg.sender] -= amount;
        _transfer(sender, recipient, amount);
        return true;
    }

    function approve(address spender, uint256 amount) public returns (bool) {
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
        require(_balances[sender] >= amount, "ERC20: Not enough funds.");

        _balances[sender] -= amount;
        _balances[recipient] += amount;
        emit Transfer(sender, recipient, amount);
    }
}

CONCLUSION

That's a wrap guys!

I've tried to cover the basics of Mappings in solidity. It's up to you to do more research on this topic for deep knowledge. Expect more indepth research and resources on Web3, Smart Contracts, and Blockchain in my subsequent Blog posts.

I'm Sunington, you can connect with me on Twitter and on LinkedIn.

Until we meet again

#KeepSunning!

Understanding Array in Solidity (Push, Pop, Length)

Sunington — Tue, 22 Nov 2022 08:23:45 +0000

Table of Contents

Arrays
Array Types
Array Members
Removing Array element by shifting to the last and using pop() command.

1) What is an Array?

Array is a data structure used to store a collection of data or variables of the same type. Instead of declaring number = number1, number2, number3. . . number(nth), we can group it as number[] = [1, 2, 3. . . nth].

What we simply did here is instead of declaring numberous individual value repeatedly, we create one array and allocate all the value in one collection of array where each value can be accessed by the index.
Now let’s talk about index. The first value in any array is of index 0. Ie : for number[] = [1, 2, 3. . . nth] discussed earlier, the index 0 denoted as *number[0] = 1, number[1] = 2, number[2] = 3. . . number[n] = n+1.
*

Creating an Array

To create an array in Solidity, the data type of the elements and the number of elements should be specified. The size of the array must be a positive integer for fixed-sized arrays and data should be a valid Solidity type.

Syntax: type[] public arrayName = [elements]

type[] is the data type of the values in the array, where [] shows it’s an array.
arrayName is the name of the array defined while elements is the value or elements of the array. The elements should be the same value type.

Code example

In the code example below, the contract myPractise defines a contract, an array type uint named arrayValue is created, values are assigned to the array defined.

pragma solidity ^ 0.8.0;
// //SPDX-License-Identifier: MIT;

contract myPractise {

uint[] public arrayValue = [1, 2, 3, 4, 5, 6, 7];
}

Accessing an Array

An element in an array is accessed by indexing the array name. This is done by placing the index of the element within square brackets after the name of the array. For example given an array

uint[] public arrayValue = [1, 2, 3, 4, 5, 6, 7];

We can access any value of the array. For instance, to access the value 4 in the array, we use the index 3, that is arrayValue[3] which outputs 4 if we run it.

Code Sample :

In the code example below, the contract myPractise defines a contract, an array type uint named arrayValue is created, values are assigned to the array defined. The function getArrayValue() is created to get the index value of 3. We then assigns x to the index then returns x to get the index value.

pragma solidity ^ 0.8.0;
 // //SPDX-License-Identifier: MIT;

 contract myPractise {

 uint[] public arrayValue = [1, 2, 3, 4, 5, 6, 7];
 function getArrayValue() public view returns (uint) {  

 uint x = arrayValue[3];
 return x;}
 }

 //Ouput = 4

Output : 4.

2) Array Types

Dynamic Array

Dynamic arrays are not predefined and are modifiable. The size and length increases automatically when we add an element to the array.

Syntax : type[] public arrayName = [array1, array2, array3. . .]

Code example :

uint[] public dynamicArray = [1,3,5,7,9];

Fixed-Sized Array

As the name suggests, the size of the array are predefined and fixed. This type of array are not modifiable. Note also that the number of array elements can not exceed the predefined size.

Syntax : type[n] public arrayName = [array1, array2, array3, array(nth)]

In the above syntax, n is the predefined size value.

Code sample :

uint[5] public fixedArray = [0,2,4,6,8];

3) Array Members

Push()

Push is used to add new element to a dynamic array, when you push a value to an array, it becomes the last value (nth element)

Syntax : arrayName.push(x)

Code example :

In the code example below, an array type uint named arrayValue is created, values are assigned to the array defined. The function popArrayValue() is created to add value to at the end. With the synthax arrayValue.push(8) we add 8 to the array, which becomes the last value of the array.

uint[] public arrayValue = [1, 2, 3, 4, 5, 6, 7];
function pushArrayValue() public {  
arrayValue.push(8);}

Pop()

Pop is used to delete or remove an element in a dynamic array from the end.

Syntax : arrayName.pop()

Code example :

In the code example below, an array type uint named arrayValue is created, values are assigned to the array defined. The function popArrayValue() is created to remove the last value. With the syntax arrayValue.pop() we remove the last value, 7.

uint[] public arrayValue = [1, 2, 3, 4, 5, 6, 7];
 function popArrayValue() public {  
 arrayValue.pop();}

.Length

Length of an array is the number of the elements contained in an array. The length of an array is of value type, uint. Length of an array is fixed when declared but can change depending on runtime parameters or modification.

Syntax : arrayName.length

Code sample :

In the code example below, an array type uint named arrayValue is created, values are assigned to the array defined. The function lenthOfArrayValue() is created to get the length of the array. We assigns x to arrayValue.length to return the length of the array.

uint[] public arrayValue = [1, 2, 3, 4, 5, 6, 7];
 function lengthOfArrayValue() public view returns (uint) {  
 uint x = arrayValue.length;
 return x;}

Delete

Delete is used to remove the index value in an array and automatically set it to 0.

Syntax : delete arrayName[x]

Code sample :

In the code example below, an array type uint named arrayValue is created, values are assigned to the array defined. The function deleteArrayValue() is created to delete a value from the array. We use delete arrrayValue[2[ to delete the index value 3 from the array, which sets it to 0.

#Note that 2 is the index number of the index value 3.

uint[] public arrayValue = [1, 2, 3, 4, 5, 6, 7];
function deleteArrayValue() public {  
delete arrayValue[2];}

The difference between delete and pop()

Delete removes an array value in any location, while pop() only removes a value at the end of an array.

Delete removes a value and automatically sets it to 0, while pop() entirely removes a value from an array.

Delete is executed with the command ‘delete arrayValue[x]’ while pop() is executed with the command ‘arrayValue.pop()’.

4) Removing Array By Shifting To The Last And Using The Pop()

Code sample :

In the code example below, an array type uint named arrayValue is defined, values are assigned to the array defined. The function removeValue(_input) is created to accept input. We then shift the input value to the last value and pop() the last value.

//REMOVING THE VALUE OF ARRAY BY SHIFTING THE VALUE INPUTED TO THE LAST,
 //THEN POP THE LAST VALUE

 uint[] public arrayValue = [1, 2, 3, 4, 5, 6, 7];
 function removeValue(uint _input) public  {
    //This shifts the input value from the array to the last value in the array
    arrayValue[_input] = arrayValue[arrayValue.length - 1];
    arrayValue.pop();}

Array Literal

An Array literals is a comma-seperated list of one or more elements in a square bracket. The elements in the array of a literal array should be of the same type otherwise it throws an error because the elements can not be implicitly converted.

For example, the array literal [1, -1] is invalid because the type of the first element is uint8 while the type of the second is int8 and they can not be implicitly converted to each other to make it work, e have to use [int(8), -1]

Code example :

CONCLUSION

That's a wrap guys!

I've tried to cover the basics of Arrays in solidity. It's up to you to do more research on this topic for deep knowledge. Expect more indepth research and resources on Web3, Smart Contracts, and Blockchain in my subsequent Blog posts.

I'm Sunington, you can connect with me on Twitter and on LinkedIn.

Until we meet again

#KeepSunning

Running Your First Smart Contract with Solidity using Remix IDE. (For Newbies)

Sunington — Sun, 12 Jun 2022 06:33:35 +0000

Since you are here, I promise you one thing : You will learn how to run your first smart contract coded in solidity.

Wait solidity? what is that?

Solidity is a contract-oriented, statically typed high-level programming language for implementing smart contracts.

Solidity is used to write contracts in DApps, DeFi, NFTs Applications and even to building Web3 Application from scratch.

It is highly influenced by C++, Python and JavaScript and has been designed to target the Ethereum Virtual Machine (EVM).

To write our first Smart Contract, we will be using Remix IDE to Compile and Run our Solidity Code base.

Let's begin...

STEP ONE

Head over to https://remix.ethereum.org to start your remix coding environment (Online Editor)

You can get the offline (For Desktop) here.

STEP TWO

Next is to create a Solidity file. To do that head over to ‘File Explorer’ then click on ‘Create File’ following the marked area on the picture below.

Note : You can name it whatever you want but make sure to end it with ‘.sol’

STEP THREE

Copy the code below and paste in Remix IDE coding section.

Code Example

pragma solidity ^0.5.0; contract SolidityTest { constructor() public{ } function getResult() public view returns(uint){ uint a = 1; uint b = 2; uint result = a + b; return result; } }

STEP FOUR

Under Compile Tab, click Start to Compile button to compile your Solidity code.

STEP FIVE

Next is to deploy and run your code. To do that go to the ‘Deploy and Run Transactions’ tab, then click ‘Deploy’ button. Make sure all the parameters under the run and deploy section is set right from img below.

STEP SIX

Under Run Tab, where you will see the Transaction record,, Select 0x75a05ff94d0c9608b8265bc08… in drop-down.

STEP SEVEN

To get the deployed result, Click ‘getResult’ button to display the result in the terminal.

Output = 3

VIOLA! You just deployed your first Smart contract!

To explain what we just did.

We assigned value a = 1, (uint a = 1) and b = 2 (uint a = 1) . Then we carried a simple math operation in solidity.

uint result a + b = (1 + 2) = 3.

Therefore 3 is the right output.

This is just the surface of writing smart contracts in solidity. As you go on, you get to see more complex code.

I’m Sunington, you can connect with me on Twitter.

Until we meet again,

#KeepSunning.

Wait! I’m stuck. Which is the Best TRUFFLE or HARDHAT?

Sunington — Mon, 06 Jun 2022 09:12:11 +0000

INTRODUCTION

Web3 and Blockchain are new technologies that rely heavily on smart contracts and to run smart contract you need a development environment that can help to compile, test, debug and deploy ethereum software (Ethereum Nodes)

WHAT IS A DEVELOPMENT ENVIRONMENT?

A Development Environment is an environment to develop, test and deploy Smart contracts carefully and initialize contracts in a better and more secure way.

There are a handful of development environments that perform such operations but Hardhat and Truffle are among the best. Even though Hardhat and Truffle are way similar we will be considering some of the differences and similarities between the two.

So let's look at some of the features of Hardhat first.

Table of Content

Hardhat - What is Hardhat?
Key Features of Hardhat
Truffle - What is Truffle?
Key Feature of Truffle
The Differences
The Similarities
Conclusion

HARDHAT : Hardhat dubs itself as the Ethereum development environment for professionals. It is an Ethereum based Development environment to build, develop, compile and deploy smart contracts created by the team at Nomic Foundation. It facilitates performing frequent tasks, such as running tests, automatically checking code for mistakes or interacting with a smart contract.

KEY FEATURES OF HARDHAT

Debugging contracts : (Supports Console.log)

Hardhat makes it a lot easy to debug your smart contract. You get solidity stack traces, can use console.log command and shows error messages when transaction fails which is very essential for developers to know where the application fails and how ro solve the error making the debugging process a lot easier.

Testing and Deploying Contracts (Pre-installed Ethereum local Testnet)

You can run solidity locally, easily deploy your contracts, run tests and debug Solidity code without dealing with live environments.

Hardhat comes with a pre-installed local ethereum network testnet. It makes it easier and possible to interact with smart contracts in testing directly without using a third party testing environment account and blockchain network like Ganache UI or Ganache CLI.

Plugins Ecosystem

Hardhat houses a range of Plugins and Libraries that enhance the functionality of hardhat and integrate your existing tools into a smooth workflow.

Community and Resources

Hardhat has an active and supportive community, but being the baby in the house previously has no much resources as compared to truffle. But with the speed of mass Developers adopting Hardhat there is now an avalanche of resources.

Usage and Flexibility

This is it, where Hardhat wears the crown for its ease of integration, flexible functionalities, allowing you to change anything you like and customizable design with little constraints.

It allows you to keep using your existing tools while enabling deeper interoperability between them and has all the utilities you need to address your project-specific needs.

Now let's look at some of the features of Truffle now

TRUFFLE : Truffle Suite as the Trufflesuite team puts it is a world class development environment, testing framework and asset pipeline for blockchain using the ethereum virtual machine crafted by ConsenSys Inc

Truffle Suite has three components:

Truffle : It is a Development Environment, Testing Framework and Asset pipeline for Ethereum Blokchains.
Ganache : Ganache is a personal Ethereum Blockchain used to test smart contracts where you can deploy contracts, develop applications, run tests and perform other tasks without any cost.
Drizzle : Drizzle is a collection of libraries used to create easy and better front-end for Ethereum DApps.

KEY FEATURES OF TRUFFLE

Smart Contract Management Circle

Truffle takes care of managing your contract artifacts so you don't have to Includes support for custom deployments, library linking and complex Ethereum applications.

Automated Contract Testing

Another helpful feature of Truffle is that it supports automated contract testing. You can write automated tests for your contracts in both JavaScript and Solidity, and get your contracts developed quickly bringing your dapp development to the 21st century

Interactive Console

Truffle uses an interactive console access to all your built contracts and all available Truffle commands to save time and talk to your contracts.

Debugging contracts

Truffle Debugger is a command line tool integrated into the Truffle Framework which allows smart contract transactions to be debugged using the smart contract code and transaction artifacts.

DIFFERENCE BETWEEN HARDHAT AND TRUFFLE

Hardhat comes with an integrated local Ethereum network to run and deploy smart contract,.
Truffle doesn't have an integrated local network. You need Ganache,a tool to set up your own local Ethereum blockchain that you can use to deploy and test your smart contracts.

Hardhat supports Typescript
Truffle does not support Typescript or does with robust configurations.

Hardhat houses Plugins ecosystem with customizable features depending on project-specific needs making it much more flexible.
Truffle is less flexible because it does not support many plugins as it has its own fixed way of doing things.

Hardhat makes debugging solidity codes easier with the console.log command that displays log messages in the terminal.
Truffle we write our own events and deal with it to test our contracts.

Hardhat gives stack traces which makes it possible to inspect what happened in your contract if you change it or where an application fails and how to solve this problem.
Truffle just gives the error message instead of actual stack traces.

Hardhat uses the Ethers.js library to interact with smart contracts as default, whereas
Truffle uses the Web3.js library to interact with smart contracts as default.

#NOTE Both can use both libraries interchangeably with some configurations.

SIMILARITIES BETWEEN HARDHAT AND TRUFFLE

Hardhat and Truffle do the same thing for you; it helps you to develop, test and deploy the smart contracts.

Hardhat and Truffle provide Javascript and Solidity based development frameworks.

Hardhat and Truffle use the Ethereum network to develop, test and deploy the smart contracts.

Hardhat and Truffle have a massive community and resources.

CONCLUSION

That's it guys!

I've tried to cover the basics of Hardhat and Truffle and lay out the differences and similarities between them.. It's up to you to choose which development environment you want to work with.

I'm Sunington, you can connect with me on Twitter. Expect more indepth research and resources on Web3, Smart Contracts, and Blockchain in my subsequent Blog posts.

Until we meet again

#KeepSunning

7 Tools you need to know as a Blockchain Developer.

Sunington — Sun, 29 May 2022 16:16:07 +0000

1) SOLIDITY: Solidity is the most used and popular language in blockchain development to write smart contracts with syntax from Javascript, C++ and Python.

As at now, Solidity is the most preferred language for most Blockchain developers.

2) REMIX IDE - Remix is an open source, web based Integrated Development Environment to write and develop solidity smart contracts (Just like VScode editors)

3) METAMASK : Metamask is a software that allows user to access the Ethereum blockchain and host arrays of decentralised Applications.

4) HARDHAT : Hardhat is an Ethereum blockchain developement environment that helps compile, deploy, test and debug your smart contracts and DApps (Equivalant of Truffle)

5) WEB3.JS : Web3.js is a collection of JS libraries that allows developers to create application that interacts with Ethereum blockchain. (with local or remote Ethereum nodes)

6) GANACHE : Ganache allows you to create a private Ethereum blockchain for developers to run, test, and execute commands. It allows you to perform all action you would on main chain with no cost.

7) SOLC (SOLIDITY COMPILER) : Solc is a JS library and command-line tool that is used to compile solidity files from High-level solidty language to an Ethereum virtual machine bytecode.

And that's a wrap! You know others tools that are not mentioned? please feel free to add in the comment section.

Liked it? Follow @sunington for more tips and resources on Web3 and Blockchain Development.

We meet again next time,

Until then, #KeepSunning!