Developers Forum for XinFin XDC Network: daniel weber

Create a Smart Contract that Returns Address and Balance of Owner using Solidity.

daniel weber — Sun, 31 Jul 2022 08:49:34 +0000

Problem: Create a smart contract named MyContract having a state variable as owner. Create a constructor to fetch the address of the owner from msg and hold it into the state variable owner. Also, create a function getBalance() to show the current balance of the owner.

Solution: Every smart contract is owned by an address called as owner. A smart contract can know its owner’s address using sender property and its available balance using a special built-in object called msg.

Step 1: Open Remix-IDE.

Step 2: Select File Explorer from the left side icons and select Solidity in the environment. Click on New option below the Solidity environment. Enter the file name as MyContract.sol and Click on the OK button.

Step 3: Enter the following Solidity Code.

// Solidity program to
// retrieve address and
// balance of owner
pragma solidity ^0.6.8; 

// Creating a contract
contract MyContract
{
    // Private state variable
    address private owner;

    // Defining a constructor
    constructor() public{
        owner=msg.sender;
    }

    // Function to get
    // address of owner
    function getOwner(
    ) public view returns (address) {   
        return owner;
    }

    // Function to return
    // current balance of owner
    function getBalance(
    ) public view returns(uint256){
        return owner.balance;
    }
}

Step 4: Compile the file MyContract.sol from the Solidity Compiler tab.

Step 5: Deploy the smart contract from the Deploy and Run Transaction tab and you will get the balance and address of the owner.

Step 6: The output below shows the address and the balance of the owner.

What is Hashing in Solidity?

daniel weber — Wed, 27 Jul 2022 04:38:55 +0000

A cryptographic hash function is an algorithm that takes an arbitrary amount of data as input and produces the enciphered text of fixed size. Even a slight change in the input gives a completely different output.

Solidity provides the following cryptographic functions:

Ethereum uses Keccak for hashing which is similar but not the same as SHA_256. For proof of work, it uses a custom scheme called ethash which is designed to be ASIC-resistant.

Example: In the below example, a smart contract is created to take a string as input and give an 8 digit hash as an output.

// pragma version
pragma solidity ^0.6.6; 

// Creating a contract
contract helloGeeks 
{
    // We want hash to be of 8 digits 
    // hence we store 10^8 which is 
    // used to extract first 8 digits 
    // later by Modulus 
    uint hashDigits = 8;

    // Equivalent to 10^8 = 8
    uint hashModulus = 10 ** hashDigits; 

    // Function to generate the hash value
    function _generateRandom(string memory _str) 
        public view returns (uint) 
    {
        // "packing" the string into bytes and 
        // then applying the hash function. 
        // This is then typecasted into uint.
        uint random = 
             uint(keccak256(abi.encodePacked(_str)));

        // Returning the generated hash value 
        return random % hashModulus;
    }

}

Input:
GeeksForGeeks

Output:

What are Enums and Structs in Solidity?

daniel weber — Tue, 19 Jul 2022 08:25:51 +0000

Enums are the way of creating user-defined data types, it is usually used to provide names for integral constants which makes the contract better for maintenance and reading. Enums restrict the variable with one of a few predefined values, these values of the enumerated list are called enums. Options are represented with integer values starting from zero, a default value can also be given for the enum. By using enums it is possible to reduce the bugs in the code.

Syntax:
enum <enumerator_name> { element 1, element 2,....,element n }

Example: In the below example, the contract Types consist of an enumerator week_days, and functions are defined to set and get the value of a variable of the type enumerator.

// Solidity program to demonstrate
// how to use 'enumerator'
pragma solidity ^0.5.0;

// Creating a contract
contract Types { 

    // Creating an enumerator
    enum week_days
    {
      Monday,
      Tuesday,
      Wednesday,
      Thursday,
      Friday,
      Saturday,
      Sunday
     } 

    // Declaring variables of
    // type enumerator
    week_days week;   

    week_days choice;

    // Setting a default value
    week_days constant default_value
      = week_days.Sunday;

    // Defining a function to
    // set value of choice
    function set_value() public {
      choice = week_days.Thursday;
    }

    // Defining a function to
    // return value of choice
    function get_choice(
    ) public view returns (week_days) {
      return choice;
    }

    // Defining function to
    //  return default value
    function getdefaultvalue(
    ) public pure returns(week_days) { 
        return default_value; 
    } 
}

Output :

Struct

Structs in Solidity allows you to create more complicated data types that have multiple properties. You can define your own type by creating a struct.

They are useful for grouping together related data.

Structs can be declared outside of a contract and imported in another contract. Generally, it is used to represent a record. To define a structure struct keyword is used, which creates a new data type.

Syntax:

struct <structure_name> { <data type> variable_1; <data type> variable_2; }
For accessing any element of the structure, ‘dot operator’ is used, which separates the struct variable and the element we wish to access. To define the variable of structure data type structure name is used.

Example: In the below example, the contract Test consists of a structure Book, and functions are defined to set and get values of the elements of the structure.

// Solidity program to demonstrate
// how to use 'structures'
pragma solidity ^0.5.0;

// Creating a contract
contract test {

   // Declaring a structure
   struct Book {
      string name;
      string writter;
      uint id;
      bool available;
   }

   // Declaring a structure object
   Book book1;

   // Assigning values to the fields
   // for the structure object book2
   Book book2
     = Book("Building Ethereum DApps",
            "Roberto Infante ",
             2, false);

   // Defining a function to set values
   // for the fields for structure book1
   function set_book_detail() public {
      book1 = Book("Introducing Ethereum and Solidity",
                   "Chris Dannen",
                    1, true);
   }


   // Defining function to print
   // book2 details
   function book_info(
   )public view returns (
     string memory, string memory, uint, bool) { 

        return(book2.name, book2.writter,
               book2.id, book2.available); 
    }

   // Defining function to print
   // book1 details
   function get_details(
   ) public view returns (string memory, uint) {
      return (book1.name, book1.id);
   }
}

Output :

Learn Mapping in Solidity that acts like a hash table or dictionary in any other language.

daniel weber — Sat, 16 Jul 2022 06:03:33 +0000

Mapping in Solidity acts like a hash table or dictionary in any other language. These are used to store the data in the form of key-value pairs, a key can be any of the built-in data types but reference types are not allowed while the value can be of any type. Mappings are mostly used to associate the unique Ethereum address with the associated value type.

Syntax:
mapping(key => value) <access specifier> <name>;

Creating a Mapping

Mapping is defined as any other variable type, which accepts a key type and a value type.

Example: In the below example, the contract mapping_example a structure is defined and mapping is created.

// Solidity program to 
// demonstrate mapping
pragma solidity ^0.4.18; 

// Defining contract 
contract mapping_example {

    //Defining structure
    struct student 
    {
        // Declaring different 
        // structure elements
        string name;
        string subject;
        uint8 marks;
    }

    // Creating a mapping
    mapping (
    address => student) result;
    address[] public student_result;    
}

Output :

Adding values to mapping

As the mapping is created let’s try to add some values to the mapping for better understanding.

Example: In the below example, the contract mapping_example defines a structure, mapping is created and values are added to the mapping.

// Solidity program to 
// demonstrate adding 
// values to mapping
pragma solidity ^0.4.18; 

// Creating contract
contract mapping_example {

    //Defining structure 
    struct student {

        //Declaring different 
        // structure elements
        string name;
        string subject;
        uint8 marks;
    }

    // Creating mapping
    mapping (
      address => student) result;
    address[] public student_result;

    // Function adding values to 
    // the mapping
    function adding_values() public {
        var student 
          = result[0xDEE7796E89C82C36BAdd1375076f39D69FafE252];

        student.name = "John";
        student.subject = "Chemistry";
        student.marks = 88;
        student_result.push(
          0xDEE7796E89C82C36BAdd1375076f39D69FafE252) -1;

    }

}

Output :

Getting values

We have added values to the mapping, to retrieve the values we have to create a function that returns the values added to the mapping.

Example: In the below example, the contract mapping_example defines a structure, mapping is created, values are added to the mapping, and values are retrieved from the mapping.

// Solidity program to
// demonstrate retrieve
// values from the mapping

pragma solidity ^0.4.18; 

contract mapping_example {

    // Defining Structure
    struct student {

        // Declaring different data types
        string name;
        string subject;
        uint8 marks;
    }

    // Creating mapping
    mapping (
      address => student) result;
    address[] student_result;

    // Function adding values to the mapping
    function adding_values() public {
        var student 
          = result[0xDEE7796E89C82C36BAdd1375076f39D69FafE252];

        student.name = "John";
        student.subject = "Chemistry";
        student.marks = 88;
        student_result.push(
          0xDEE7796E89C82C36BAdd1375076f39D69FafE252) -1;

    }

     // Function to retrieve 
     // values from a mapping
     function get_student_result(
     ) view public returns (address[]) {
        return student_result;
    }
}

Output :

Counting Mappings

Mappings can be counted so that we can know how many values are stored in mapping.

Example: In the below example, the contract mapping_example defines a structure, mapping is created, values are added to the mapping, and values are retrieved from the mapping.

// Solidity program to
// count number of 
// values in a mapping
pragma solidity ^0.4.18; 

contract mapping_example {

    // Defining structure
    struct student {

        // Declaring different
        // structure elements
        string name;
        string subject;
        uint8 marks;
    }

    // Creating mapping
    mapping (address => student) result;
    address[] student_result;

    //Function adding values to the mapping
    function adding_values() public {
        var student
          = result[0xDEE7796E89C82C36BAdd1375076f39D69FafE252];

        student.name = "John";
        student.subject = "Chemistry";
        student.marks = 88;
        student_result.push(
          0xDEE7796E89C82C36BAdd1375076f39D69FafE252) -1;

    }

     // Function to retrieve 
     // values from the mapping
     function get_student_result(
     ) view public returns (address[]) {
        return student_result;
    }

    // Function to count number 
    // of values in a mapping
    function count_students(
    ) view public returns (uint) {
        return student_result.length;
    }
}

Output :

Learn about Arrays in Solidity.

daniel weber — Wed, 13 Jul 2022 07:44:20 +0000

Arrays are data structures that store the fixed collection of elements of the same data types in which each and every element has a specific location called index. Instead of creating numerous individual variables of the same type, we just declare one array of the required size and store the elements in the array and can be accessed using the index. In Solidity, an array can be of fixed size or dynamic size. Arrays have a continuous memory location, where the lowest index corresponds to the first element while the highest represents the last

Creating an Array

To declare 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 and data type should be a valid Solidity type

Syntax:
<data type> <array name>[size] = <initialization>

Fixed-size Arrays

The size of the array should be predefined. The total number of elements should not exceed the size of the array. If the size of the array is not specified then the array of enough size is created which is enough to hold the initialization.

Example: In the below example, the contract Types are created to demonstrate how to declare and initialize fixed-size arrays.

// Solidity program to demonstrate 
// creating a fixed-size array 
pragma solidity ^0.5.0;  

// Creating a contract 
contract Types {  

    // Declaring state variables
    // of type array
    uint[6] data1;    

    // Defining function to add 
    // values to an array 
    function array_example() public returns (
    int[5] memory, uint[6] memory){  

        int[5] memory data 
        = [int(50), -63, 77, -28, 90];  
        data1 
        = [uint(10), 20, 30, 40, 50, 60];

        return (data, data1);  
  }  
}

Output :

Dynamic Array:

The size of the array is not predefined when it is declared. As the elements are added the size of array changes and at the runtime, the size of the array will be determined.

Example: In the below example, the contract Types are created to demonstrate how to create and initialize dynamic arrays.

// Solidity program to demonstrate 
// creating a dynamic array
pragma solidity ^0.5.0;  

// Creating a contract  
contract Types {  

    // Declaring state variable 
    // of type array. One is fixed-size
    // and the other is dynamic array
    uint[] data 
      = [10, 20, 30, 40, 50]; 
    int[] data1;  

    // Defining function to 
    // assign values to dynamic array
    function dynamic_array() public returns(
      uint[] memory, int[] memory){  

        data1 
          = [int(-60), 70, -80, 90, -100, -120, 140]; 
        return (data, data1);  
    }  
}

Output :

Array Operations

1. Accessing Array Elements: The elements of the array are accessed by using the index. If you want to access ith element then you have to access (i-1)th index.

Example: In the below example, the contract Types first initializes an array[data] and then retrieves the value at specific index 2.

// Solidity program to demonstrate
// accessing elements of an array
pragma solidity ^0.5.0;  

// Creating a contract 
contract Types {  

    // Declaring an array
    uint[6] data;    

    // Defining function to 
    // assign values to array
    function array_example(
    ) public payable returns (uint[6] memory){  

        data 
          = [uint(10), 20, 30, 40, 50, 60];
        return data;  
  } 

  // Defining function to access
  // values from the array
  // from a specific index  
  function array_element(
  ) public payable returns (uint){  
        uint x = data[2];
        return x;  
  }  
}

Output :

2. Length of Array: Length of the array is used to check the number of elements present in an array. The size of the memory array is fixed when they are declared, while in case the dynamic array is defined at runtime so for manipulation length is required.

Example: In the below example, the contract Types first initializes an array[data] and then the length of the array is calculated.

// Solidity program to demonstrate 
// how to find length of an array
pragma solidity ^0.5.0;  

// Creating a contract
contract Types {  

    // Declaring an array
    uint[6] data;    

    // Defining a function to 
    // assign values to an array
    function array_example(
    ) public payable returns (uint[6] memory){  
        data = [uint(10), 20, 30, 40, 50, 60];
        return data;  
  }  

  // Defining a function to 
  // find the length of the array
  function array_length(
  ) public returns(uint) {  
        uint x = data.length;
        return x; 
    } 
  }

Output :

3. Push: Push is used when a new element is to be added in a dynamic array. The new element is always added at the last position of the array.

Example: In the below example, the contract Types first initializes an array[data], and then more values are pushed into the array.

// Solidity program to demonstrate 
// Push operation
pragma solidity ^0.5.0;  

// Creating a contract 
contract Types {  

    // Defining the array
    uint[] data = [10, 20, 30, 40, 50]; 

    // Defining the function to push 
    // values to the array
    function array_push(
    ) public returns(uint[] memory){  

        data.push(60);  
        data.push(70);  
        data.push(80);

        return data;  
    }  
}

*Output : *

4. Pop: Pop is used when the last element of the array is to be removed in any dynamic array.

Example: In the below example, the contract Types first initializes an array[data], and then values are removed from the array using the pop function.

// Solidity program to demonstrate
// Pop operation
pragma solidity ^0.5.0;  

// Creating a contract
contract Types {  

    // Defining an array
    uint[] data 
      = [10, 20, 30, 40, 50];

    // Defining a function to 
    // pop values from the array
    function array_pop(
    ) public returns(uint[] memory){  
        data.pop(); 
        return data;  
    }  
}

Output :

Today Let's Learn about Solidity – Operators.

daniel weber — Mon, 11 Jul 2022 06:38:34 +0000

In any programming language, operators play a vital role i.e. they create a foundation for the programming. Similarly, the functionality of Solidity is also incomplete without the use of operators. Operators allow users to perform different operations on operands. Solidity supports the following types of operators based upon their functionality.

Arithmetic Operators
Relational Operators
Logical Operators
Bitwise Operators
Assignment operators
Conditional Operator

Arithmetic Operators

These operators are used to perform arithmetic or mathematical operations. Solidity supports the following arithmetic operators:

Example: In the below example, the contract SolidityTest demonstrates the above mentioned different types of arithmetic operators.

// Solidity contract to demonstrate
// Arithmetic Operator
pragma solidity ^0.5.0;

// Creating a contract
contract SolidityTest {

    // Initializing variables
    uint16 public a = 20;
    uint16 public b = 10;

    // Initializing a variable
    // with sum
    uint public sum = a + b;

    // Initializing a variable
    // with the difference
    uint public diff = a - b;

    // Initializing a variable
    // with product
    uint public mul = a * b;

    // Initializing a variable
    // with quotient
    uint public div = a / b;

    // Initializing a variable
    // with modulus
    uint public mod = a % b;

    // Initializing a variable
    // decrement value
    uint public dec = --b;

    // Initializing a variable
    // with increment value
    uint public inc = ++a;

}

Output :

Relational Operators

These operators are used to compare two values. Solidity supports the following relational operators:

Example: In the below example, the contract SolidityTest demonstrates the above mentioned different types of relational operators.

// Solidity program to demonstrate
// Relational Operator
pragma solidity ^0.5.0;

// Creating a contract
contract SolidityTest {

    // Declaring variables
    uint16 public a = 20;
    uint16 public b = 10;

    // Initializing a variable
    // with bool equal result
    bool public eq = a == b;

    // Initializing a variable
    // with bool not equal result
    bool public noteq = a != b;

    // Initializing a variable
    // with bool greater than result
    bool public gtr = a > b;

    // Initializing a variable
    // with bool less than result
    bool public les = a < b;

    // Initializing a variable
    // with bool greater than equal to result
    bool public gtreq = a >= b;

    // Initializing a variable
    // bool less than equal to result
    bool public leseq = a <= b;

}

Output :

Logical Operators

These operators are used to combine two or more conditions. Solidity supports the following arithmetic operators :

Example: In the below example, the contract logicalOperator demonstrates the above mentioned different types of logical operators.

// Solidity program to demonstrate
// Logical Operators
pragma solidity ^0.5.0;

// Creating a contract
contract logicalOperator{

     // Defining function to demonstrate
     // Logical operator
     function Logic(
       bool a, bool b) public view returns(
       bool, bool, bool){

       // Logical AND operator 
       bool and = a&&b;

       // Logical OR operator 
       bool or = a||b;

       // Logical NOT operator
       bool not = !a;
       return (and, or, not);
 }
}

Output :

Bitwise Operators

These operators work at a bit level used to perform bit-level operations. Solidity supports the following arithmetic operators:

Example: In the below example, the contract SolidityTest demonstrates the above mentioned different types of bitwise operators.

// Solidity program to demonstrate
// Bitwise Operator
pragma solidity ^0.5.0;

// Creating a contract
contract SolidityTest {

    // Declaring variables
    uint16 public a = 20;
    uint16 public b = 10;

    // Initializing a variable
    // to '&' value
    uint16 public and = a & b;

    // Initializing a variable
    // to '|' value
    uint16 public or = a | b;

    // Initializing a variable
    // to '^' value
    uint16 public xor = a ^ b;

    // Initializing a variable
    // to '<<' value
    uint16 public leftshift = a << b;

    // Initializing a variable
    // to '>>' value
    uint16 public rightshift = a >> b;

    // Initializing a variable
    // to '~' value
    uint16 public not = ~a ;

}

Output :

Assignment Operator

These operators are for the assignment of value to a variable. The operand at the left side is variable while operand at the right side is value. Solidity supports the following arithmetic operators :

Example: In the below example, the contract SolidityTest demonstrates the above mentioned different types of assignment operators.

// Solidity program to demonstrate
// Assignment Operator
pragma solidity ^0.5.0;

// Creating a contract
contract SolidityTest {

        // Declaring variables
        uint16 public assignment = 20;
        uint public assignment_add = 50;
        uint public assign_sub = 50;
        uint public assign_mul = 10;
        uint public assign_div = 50;
        uint public assign_mod = 32;

        // Defining function to
        // demonstrate Assignment Operator
        function getResult() public{
           assignment_add += 10;
           assign_sub -= 20;
           assign_mul *= 10;
           assign_div /= 10;
           assign_mod %= 20;
           return ;
        }
}

Output :

Conditional Operators

It is a ternary operator that evaluates the expression first then checks the condition for return values corresponding to true or false.

Syntax:

if condition true ? then A: else B

Example: In the below example, the contract SolidityTest demonstrates the conditional operator.

// Solidity program to demonstrate
// Conditional Operator
pragma solidity ^0.5.0;

// Creating a contract
contract SolidityTest{

     // Defining function to demonstrate
     // conditional operator
     function sub(
       uint a, uint b) public view returns(
       uint){
      uint result = (a > b? a-b : b-a);
      return result;
 }
}

Output :

Let's Learn Solidity - Variables.

daniel weber — Thu, 07 Jul 2022 12:57:30 +0000

A Variable is basically a placeholder for the data which can be manipulated at runtime. Variables allow users to retrieve and change the stored information.

Rules For Naming Variables

A variable name should not match with reserved keywords.
Variable names must start with a letter or an underscore (_), and may contain letters from “a to z” or “A to Z” or digits from “0 to 9” and characters also.

Example:

Geeks123, geeks, _123geeks are valid variable names 123geeks, $Geeks, 12_geeks are invalid variable names

The name of variables are case sensitive i.e.

Example:

Geeks123 and geeks123 are different variables

Declaration of Variables

In Solidity declaration of variables is a little bit different, to declare a variable the user has to specify the data type first followed by access modifier.

Syntax:

<type> <access modifier> <variable name> ;

Example:

int public int_var;

Types of Variables

Solidity is a statically typed language i.e. each declared variable always has a default value based on its data type, which means there is no concept of ‘null’ or ‘undefined’. Solidity supports three types of variables:

1. State Variables: Values of these variables are permanently stored in the contract storage. Each function has its own scope, and state variables should always be defined outside of that scope.

Example: In the below example. the contract Solidity_var_Test initializes the values of an unsigned integer state variable using a constructor.

Solidity

// Solidity program to 
// demonstrate state 
// variables
pragma solidity ^0.5.0;

// Creating a contract
contract Solidity_var_Test {

   // Declaring a state variable
   uint8 public state_var;      

   // Defining a constructor
   constructor() public {
      state_var = 16;   
   }
}

Output :

2. Local Variable: Values of these variables are present till the function executes and it cannot be accessed outside that function. This type of variable is usually used to store temporary values.

Example: In the below example, the contract Solidity_var_Test defines a function to declare and initialize the local variables and return the sum of the two local variables.

Solidity

// Solidity program to demonstrate
// local variables
pragma solidity ^0.5.0;

// Creating a contract
contract Solidity_var_Test {

   // Defining function to show the declaration and
   // scope of local variables
   function getResult() public view returns(uint){

      // Initializing local variables
      uint local_var1 = 1; 
      uint local_var2 = 2;
      uint result = local_var1 + local_var2;

      // Access the local variable
      return result; 
   }
}

Output :

3. Global Variables: These are some special variables that can be used globally and give information about the transactions and blockChain properties. Some of the global variables are listed below :

Example: In the below example, the contact Test uses the msg.sender variable to access the address of the person deploying the contract.

Solidity

// Solidity program to 
// show Global variables
pragma solidity ^0.5.0;

// Creating a contract
contract Test { 

  // Defining a variable
  address public admin;

  // Creating a constructor to
  // use Global variable
  constructor() public {    
    admin = msg.sender;  
  }
 }

Output:

Learn Solidity – While, Do-While, and For Loop.

daniel weber — Mon, 04 Jul 2022 09:57:56 +0000

Loops are used when we have to perform an action over and over again. While writing a contract there may be a situation when we have to do some action repeatedly, In this situation, loops are implemented to reduce the number of lines of the statements. Solidity supports following loops too ease down the programming pressure.

While Loop

This is the most basic loop in solidity, Its purpose is to execute a statement or block of statements repeatedly as far as the condition is true and once the condition becomes false the loop terminates.

Syntax:
while (condition) { statement or block of code to be executed if the condition is True }

Example: In the below example, the contract Types demonstrate the execution of a while loop and how an array can be initialized using the while loop.

// Solidity program to 
// demonstrate the use
// of 'While loop'
pragma solidity ^0.5.0; 

// Creating a contract 
contract Types { 

    // Declaring a dynamic array
    uint[] data; 

    // Declaring state variable
    uint8 j = 0;

    // Defining a function to 
    // demonstrate While loop'
    function loop(
    ) public returns(uint[] memory){
    while(j < 5) {
        j++;
        data.push(j);
     }
      return data;
    }
}

Output :

Do-While Loop

This loop is very similar to while loop except that there is a condition check which happens at the end of loop i.e. the loop will always execute at least one time even if the condition is false.

Syntax:

do { block of statements to be executed } while (condition);
Example: In the below example, the contract Types demonstrate the execution of a do-while loop and how an array can be initialized using the do-while loop.

// Solidity program to 
// demonstrate the use of
// 'Do-While loop'
pragma solidity ^0.5.0; 

// Creating a contract 
contract Types { 

    // Declaring a dynamic array
    uint[] data; 

    // Declaring state variable
    uint8 j = 0;

    // Defining function to demonstrate 
    // 'Do-While loop'
    function loop(
    ) public returns(uint[] memory){
    do{
        j++;
        data.push(j);
     }while(j < 5) ;
      return data;
    }
}

Output :

For Loop

This is the most compact way of looping. It takes three arguments separated by a semi-colon to run. The first one is ‘loop initialization’ where the iterator is initialized with starting value, this statement is executed before the loop starts. Second is ‘test statement’ which checks whether the condition is true or not, if the condition is true the loop executes else terminates. The third one is the ‘iteration statement’ where the iterator is increased or decreased. Below is the syntax of for loop :

Syntax:
for (initialization; test condition; iteration statement) { statement or block of code to be executed if the condition is True }

Example: In the below example, the contract Types demonstrate the execution of a while loop and how an array can be initialized using the while loop.

// Solidity program to 
// demonstrate the use
// of 'For loop'
pragma solidity ^0.5.0; 

// Creating a contract
contract Types { 

    // Declaring a dynamic array 
    uint[] data; 

    // Defining a function 
    // to demonstrate 'For loop'
    function loop(
    ) public returns(uint[] memory){
    for(uint i=0; i<5; i++){
        data.push(i);
     }
      return data;
    }
}

Output :

Learn About Solidity – Constructors with Examples.

daniel weber — Sat, 02 Jul 2022 05:19:34 +0000

A constructor is a special method in any object-oriented programming language which gets called whenever an object of a class is initialized. It is totally different in case of Solidity, Solidity provides a constructor declaration inside the smart contract and it invokes only once when the contract is deployed and is used to initialize the contract state. A default constructor is created by the compiler if there is no explicitly defined constructor.

Creating a constructor

A Constructor is defined using a constructor keyword without any function name followed by an access modifier. It’s an optional function which initializes state variables of the contract. A constructor can be either internal or public, an internal constructor marks contract as abstract.

Syntax:
constructor() <Access Modifier> { }

Example: In the below example, in the contract constructorExample, a constructor is created to initialize the state variable str.


// Solidity program to demonstrate
// creating a constructor
pragma solidity ^0.5.0;       

// Creating a contract
contract constructorExample {       

    // Declaring state variable
    string str;       

    // Creating a constructor
    // to set value of 'str'
    constructor() public {                 
        str = "GeeksForGeeks";       
    }       

    // Defining function to
    // return the value of 'str' 
    function getValue(
    ) public view returns (
      string memory) {       
        return str;       
    }     
}

Output :

Constructor in Inheritance
In case if a constructor is not defined then the default constructor is called, but if the constructor is defined in a parent contract and having some arguments then the child contract should also provide the required parameters to the constructor. If the child contract is not passing any parameter to the parent’s constructor the child contract will become an abstract contract. There are two ways of calling a parent contract’s constructor:

1. Direct Initialization: In the below example, the direct initialization method is used to initialize the constructor of the parent class.

// Solidity program to demonstrate
// Constructor in Inheritance
pragma solidity ^0.5.0;

// Creating a contract
contract Base {

   // Declaring variable
   uint data;

   // Defining a constructor
   constructor(uint _data) public {
      data = _data;  
   }

   // Defining function
   function Print(
   ) public  returns(string memory){
       return "Direct Initialization";
   }

}

// Child contract inheriting
// the parent contract 'Base'
contract Derived is Base(2){

    // Defining a constructor
    constructor() public {}

   // Defining function to access
   // variable of parent contract
   function getData(
   ) external returns(uint){
       uint result = data ** 2;
       return result;
   }
}

// Caller contract
contract caller{

   // Creating an object of child contract
    Derived c = new Derived();

   // Accessing functions of parent
   // and child contract using
   // object of child contract
    function getResult() public returns(uint){
        c.Print();
        return c.getData();
    }
}

Output :

2. Indirect Initialization: In the below example, the indirect initialization using Base(string(abi.encodePacked(_info, _info))) is done to initialize the constructor of the base class.


// Solidity program to demonstrate
// Indirect Initialization
pragma solidity ^0.5.0;

// Creating a contract
contract Base {

   // Declaring state variable
   string str;

   // Defining a constructor
   constructor(
     string memory _str) public {
      str = _str;  
   }

   // Defining a function
   function Print(
   ) public returns(string memory){
       return "Indirect Initialization";
   }
}

// Child contract inheriting
// parent contract 'Base'
contract Derived is Base {

   // Defining a constructor
   constructor(
     string memory _info) Base(
     string(abi.encodePacked(
       _info, _info))) public {}

   // Defining function to
   // return value of parent
   // contract variable 'str'
   function getStr(
   ) public view returns(string memory){
       return str;
   }
}

// Caller contract
contract caller {

    // Creating an object of
    // child contract
    Derived c
      = new Derived("GeeksForGeeks");

    //Defining a function to access
    // functions of the parent
    //contract and child contract
    function getResult() public view{
        c.Print();
        c.getStr();
    }
}

Output :

Need of Constructors

Constructors are very useful in a smart contract, a parameter value can be defined at the run time and can also restrict the method call. Constructor overloading is not supported in Solidity, it only allows one constructor at a time.

Example: In the below example, the contract constructorExample consists of a constructor to demonstrate the need for the constructor.


// Solidity program to demonstrate
// Need of constructors
pragma solidity ^0.5.0;       

// Creating a contract
contract constructorExample {       

    // Declaring state variable
    string str;       
    address private owner
      = 0x62Ab98A0efB752C48bd82836D0b4335018B9B97e;

    // Defining constructor
    constructor(string memory string) public {                 
        if(msg.sender == owner){   
            str = string;   
        }       
    }       

    // Defining function to
    // return value of 'str'  
    function getValue() public view returns (
      string memory) {       
        return str;       
    }     
}

Output :

Steps to Execute Solidity Smart Contract using Remix IDE

daniel weber — Thu, 30 Jun 2022 05:48:59 +0000

Remix IDE is generally used to compile and run Solidity smart contracts. Below are the steps for the compilation, execution, and debugging of the smart contract.

Step 1: Open Remix IDE on any of your browsers, select on the New File and click on Solidity to choose the environment.

Step 2: Write the Smart contract in the code section, and click the Compile button under the Compiler window to compile the contract.

Step 3: To execute the code, click on the Deploy button under Deploy and Run Transactions window.

Step 4: After deploying the code click on the method calls under the drop-down of deployed contracts to run the program, and for output, check to click on the drop-down on the console.

Step 5: For debugging click on the Debug button corresponding to the method call in the console. Here you can check each function call and variable assignments.

An Introduction to Solidity with an example. | What is Solidity?

daniel weber — Tue, 28 Jun 2022 08:29:54 +0000

Solidity is a brand-new programming language created by the Ethereum which is the second-largest market of cryptocurrency by capitalization, released in the year 2015 led by Christian Reitwiessner.

Some key features of solidity are listed below:

Solidity is a high-level programming language designed for implementing smart contracts.
It is statically-typed object-oriented(contract-oriented) language.
Solidity is highly influenced by Python, c++, and JavaScript which runs on the Ethereum Virtual Machine(EVM).
Solidity supports complex user-defined programming, libraries and inheritance.
Solidity is primary language for blockchains running platforms.
Solidity can be used to creating contracts like voting, blind auctions, crowdfunding, multi-signature wallets, etc.

Ethereum Virtual Machine(EVM)

Ethereum Virtual Machine abbreviated as EVM is a runtime environment for executing smart contracts in ethereum and EVM compatible networks. It focuses widely on providing security and execution of untrusted code using an international network of public nodes. EVM is specialized to prevent Denial-of-service attack and confirms that the program does not have any access to each other’s state, also ensures that the communication is established without any potential interference.

Smart Contract

Smart contracts are high-level program codes that are compiled to EVM byte code and deployed to the ethereum blockchain for further execution. It allows us to perform credible transactions without any interference of the third party, these transactions are trackable and irreversible. Languages used to write smart contracts are Solidity (a language library with similarities to C and JavaScript), Serpent (similar to Python, but deprecated), LLL (a low-level Lisp-like language), and Mutan (Go-based, but deprecated).

Example: In the below example, we have discussed a sample solidity program to demonstrate how to write a smart contract in Solidity.

// Solidity program to
// demonstrate how to
// write a smart contract
pragma solidity >= 0.4.16 < 0.7.0;

// Defining a contract
contract Test
{

    // Declaring state variables
    uint public var1;
    uint public var2;
    uint public sum;

    // Defining public function
    // that sets the value of
    // the state variable
    function set(uint x, uint y) public
    {
        var1 = x;
        var2=y;
        sum=var1+var2;
    }

    // Defining function to
    // print the sum of
    // state variables
    function get(
    ) public view returns (uint) {
        return sum;
    }
}

Output:

Explanation:

1. Version Pragma:

pragma solidity >=0.4.16 <0.7.0;
Pragmas are instructions to the compiler on how to treat the code. All solidity source code should start with a “version pragma” which is a declaration of the version of the solidity compiler this code should use. This helps the code from being incompatible with the future versions of the compiler which may bring changes. The above-mentioned code states that it is compatible with compilers of version greater than and equal to 0.4.16 but less than version 0.7.0.

2. The contract keyword:

contract Test{ //Functions and Data }
The contract keyword declares a contract under which is the code encapsulated.

3. State variables:

uint public var1; uint public var2; uint public sum;
State variables are permanently stored in contract storage that they are written in Ethereum Blockchain. The line uint public var1 declares a state variable called var1 of type uint (unsigned integer of 256 bits). Think of it as adding a slot in a database. Similarly, goes with the declaration uint public var2 and uint public sum.

4. A function declaration:

function set(uint x, uint y) public function get() public view returns (uint)

This is a function named set of access modifier type public which takes a variable x and variable y of datatype uint as a parameter.
This was an example of a simple smart contract which updates the value of var1 and var2. Anyone can call the function set and overwrite the value of var1 and var2 which is stored in Ethereum blockchain. This is an example of a decentralized application that is censorship proof and unaffected to the shutdown of any centralized server. As long as someone is running a single node of Ethereum blockchain, this smart contract will be accessible.
The variable sum is calculated by adding the values of the variables var1 and var2.
Function get will retrieve and print the value of the state variable sum.

How to Execute The Code:

There are practically two ways to execute a solidity smart contract:

Offline Mode: Running a solidity smart contract in Offline mode requires three prerequisites and 4 major steps to be followed to get the smart contract running:

Prerequisites:

Download and install node.js.
Install Truffle globally.
Install ganache-cli.

Objectives:

Create a truffle project and configure a development network
Create and deploy smart contracts
Interact with the smart contract from Truffle console
Write tests for testing main features offered by Solidity

Online Mode: Remix IDE is generally used to compile and run Solidity smart contracts in the Online Mode.

How to Install Solidity in Windows?

daniel weber — Mon, 27 Jun 2022 11:24:39 +0000

To install solidity on windows ensure that you are using windows 10, as only windows 10 provides built-in Linux Subsystem. With the help of this feature, we can run the Ubuntu terminal on the Windows machine.

Below are the steps to setup Solidity on windows:

Step 1: Open control panel on your system and toggle to Windows Subsystem for Linux under Control Panel > Programs > Programs and Features >Turn Windows features on or off.

Step 2: After your system restarts install “Ubuntu LTS 18.04” from Microsoft store and after installation set it up.

Step 3: After setting up Bash install and check necessary dependencies like cURL, Node version manager(NVM), NodeJS and Node Packet Manager(NPM) using the following commands:

Installing cURL :
sudo apt-get install curl
curl --version

Installing NVM:
curl -o-https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
nvm --version

Installing NodeJS and NPM:
nvm install node
node --version
npm --version

After installing the dependencies, install and check solidity compiler solc by using following code:
npm install -g solc
solcjs --version