solidity programming.pptx

What is Solidity?
Ethereum Solidity is a contract-oriented, high-level language with
syntax like that of JavaScript.
A solidity is a tool used to generate a machine-level code to
execute on EVM.
The solidity compiler takes the high-level code and breaks it
down into simpler instructions.

Contracts in Ethereum Solidity
A contract is the fundamental building block of Ethereum’s decentralized
Applications. All variables and functions are part of a contract and this is the
starting point of all the projects.
1
2
3
version pragma ^0.4.19;
contract MyFirst{
}
An empty contract named MyFirst would look like this:

Layout of Solidity File
Source files can contain an arbitrary number of contract definitions, include directives and
pragma directives.
Version Pragma
Version Pragma is the declaration of the version of the Solidity compiler that the particular code
should use.
1. version pragma ^0.4.00;
Note: The source file shown above will not compile with a compiler earlier than version 0.4.0 and it will
also not work on a compiler starting from version 0.5.0.

Importing other Source Files
Ethereum Solidity supports import statements that are very similar to those available in JavaScript,
although Solidity does not know the concept of a “default export”.
At a global level you can use import statements of the following form:
1 import "filename";
The above statement imports all global symbols from “filename” into the current global scope.
1 import * as symbolName from "filename";
…creates a new global symbol symbolName whose members are all the global symbols from “filename”

Comments
Just like any other language, single line and multi-line comments are possible in Solidity.
1
2
3
4
5
// This is a single-line comment.
/*
This is a
multi-line comment
*/
Now, before we move further in our Solidity tutorial, you should know that Ethereum has three
areas where it can store items.
1. Storage: where all the contract state variables reside. Every contract has its own storage and it is
persistent between function calls
2. Memory: hold temporary values and gets erased between (external) function calls and is cheaper to
use
3. Stack: hold small local variables and is almost free to use, but can only hold a limited amount of
values
For almost all the types, you cannot specify where they should be stored, because they are copied
every time they are used.
Alright, now that you are aware of the storage locations in Ethereum Solidity, let me tell you about the
general value types.

Value Types in Solidity
The following types are also called value types because variables of these types will always be passed by
value.
Boolean
Keyword: Bool
The possible values are constants i.e., true or false

Integers
Keyword: int/uint (uint8 to uint256 in steps of 8 (unsigned of 8 up to 256 bits) and int8 to int256)
Signed and unsigned integers of various sizes.
Example:
1
2
3
contract MySample{
uint UnsignedInt =50;
}
In the above statement, we have created a uint called InsignedInt & set it to 50.
uint is a keyword that is used to declare a variable which can store an integral type of
value (unsigned integer) from the range of 0 to 4,294,967,295. It keyword is an alias of System. ... uint
keyword occupies 4 bytes (32 bits) space in the memory.

Address:
Keyword: address
Holds a 20-byte value (size of an Ethereum address). Address types also have members and serve as a base
for all contracts.
Members of Addresses: Balance & Transfer
It is possible to query the balance of an address using the property balance and to send Ether to an address
using the transfer function.
1
2
3
4
address x = 0x123;
address myAddress = this;
if (x.balance < 10 && myAddress.balance > = 10) x.transfer(10);
Strings:
Keyword: String literals are written with either double or single-quotes “foo” or ‘bar’.
Used for arbitrary-length UTF-data.
1 string language = "Solidity";
These value types can interact with each other in expressions containing operators. Next, in our
Solidity tutorial, let me tell you about the various operators.

Operators
Operators in solidity are same as in JavaScript. Solidity has four types of operators:

Incremental Operators
Incremental operators in solidity: a++, a–, ++a, –a, a+=1, a=a+1
Rules applicable to other programming languages are similar in solidity also.
Bitwise Operators:
Following are the operators: (Bitwise OR) ‘|’, (Bitwise XOR), (Bitwise negation) ‘~’ , (Bitwise right shift) ‘>>’,
(Bitwise left shift) ‘<<‘
Logical Operators:
Logical operators in Solidity: ! (logical negation), && (logical and), || (logical or), ==(equality), != (not equal)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
contract operators {
// Arithmetic Operators
// +,-,*,/, %, **
// Incremental Operators
// a++, a--, a+=1, a=a+1,++a,--a;
a=10;
a= a++; //here, output will be 10, because the value is first returned and then then increment is done
a=++a;
//Logical Operators
!, &&, ||, ==, !=
isOwner = true && false;
var orValue= 0x02 | 0x01; // output would be 0x03
//Bitwise Operators~,>>, <<;
function Operators() {
// Initialize state variables here}}

Now Sometimes there is a need for a more complex data type. For this Solidity provides structs.
Data Structures in Solidity
Solidity provides three types of data structures:

Structs
Solidity provides a way to define new types in the form of structs. Structs are custom defined types that can
group several variables.
1
2
3
4
5
6
7
8
9
pragma solidity ^0.4.0;
contract Ballot {
struct Voter { // Struct
uint weight1, weight2, weight3;
bool voted;
address delegate1, delegate2, delegate3, delegate4;
string name;
uint vote1, vote2, vote3, vote4, vote5;
uint height1, height2, height3 } }
Note: Structs can only have 16 members, exceeding which the following error might occur: Stack too Deep.
Structs allow you to create more complicated data types that have multiple properties.
Now, what if you need a collection of something, say addresses. Well, just like most of the languages,
Solidity also has Arrays.

Arrays
Arrays in Solidity can have a compile-time fixed size or they can be dynamic.
1 uint[3] fixed; //array of fixed length 3
1
uint[] dynamic; //a dynamic array has no fixed size, it can
keep growing
You can also create an array of structs. Using the previously created Voter struct:
Note: declaring an array as public will automatically create a better method for it
1 Voter[] voting;
1 Voter[] public voting;

Mappings
Mappings can be seen as hash tables which are virtually initialized such that every possible key exists and is
mapped to a value whose byte-representation is all zeros: a type’s default value.
Mappings are declared as:
1 Mapping(_Keytype => _ValueType )
Note: _Keytype can be almost any type except for a dynamically sized array, a contract, an enum and a
struct.
Example:
1
2
3
4
5
6
7
8
9
10
contract MappingExample {
mapping(address => uint) public balances;
function update(uint newBalance) {
balances[msg.sender] = newBalance; }}
contract MappingUser {
function f() returns (uint) {
MappingExample m = new MappingExample();
m.update(100);
return m.balances(this);
}}

Control Structures
Most of the control structures in JavaScript are available in Solidity except for switch and goto.
So there is: if, else, while, do, for, break, continue, return, ? :, with the usual semantics known from C
or JavaScript.
Note: There is no type conversion from non-boolean to boolean types as there is in C and JavaScript.
Now let’s see how these Control structures are used in Solidity.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
contract ControlStructure {
address public a;
function ControlStructure>){
// if-else can be used like this
if(input1==2)
a=1;
else
a=0;
// while can be used like this
while(input1>=0){
if(input1==5)
continue;
input1=input1-1;
a++;}
// for loop can be used like this
for(uint i=0;i<=50;i++) { a++; if(a==4) break; } //do while can be used like this do { a--; } (while a>0);
// Conditional Operator can be used like this
bool IsTrue = (a == 1)?true: false;
/*will show an error because
there is no type conversion from non-boolean to boolean
*/
if(1)
{
}

Moving on with our Solidity tutorial blog, let’s talk about the executable units of code within a Contract.
These are called functions.
Functions
Here is how a function is declared in Solidity.
1
2
function sampleFunc(string name, uint amount) {
}
The above-declared is an empty body function which takes two parameters: a string and a uint.
You would call this function like:
1 sampleFunc("Shashank", 10000);
Talking about functions, Solidity also provides function modifiers.
Function Modifiers
It is used to easily change the behavior of the functions. These conditions can be checked before
even making the function calls because they have been declared in the function definitions in the
smart contracts.

Example: If you want to call a kill contract function through only the owner or creator of the function.
1
2
3
4
5
6
7
8
9
10
11
contract FunctionModifiers{
address public creator;
function FunctionModifiers() {
creator = msg.sender;}
Modifier onlyCreator() {
if(msg.sender!=creator){
throw; }
_; //resumes the function wherever the access modifier is used
}
function killContract() onlyCreator{ //function will not execute if an exception occurs
self-destruct(creator); }}

Inheritance
Solidity supports multiple Inheritance by copying code including polymorphism.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
contract Owned {
address Owner ;
function owned() {
owner = msg.sender;
}}
contract Mortal is Owned { // 'is' keyword is used for inheritance
function kill(){
self-destruct(owner); }}
contract User is Owned, Mortal //Multiple inheritance
{
string public UserName;
function User(string _name){
UserName = _name;
}}
Alright, I feel the above-discussed concepts are sufficient enough for you to kick-start with Solidity
programming.

Scope of local variables is limited to function in which they are defined but
State variables can have three types of scopes.
Public − Public state variables can be accessed internally as well as via
messages. For a public state variable, an automatic getter function is
generated.
Internal − Internal state variables can be accessed only internally from the
current contract or contract deriving from it without using this.
Private − Private state variables can be accessed only internally from the
current contract they are defined not in the derived contract from it.

contract C {
uint public data = 30;
uint internal iData= 10;
uint storedData;
function x() public returns (uint) {
data = 3; // internal access
return data;
}
}
contract Caller {
C c = new C();
function f() public view returns (uint) {
return c.data(); //external access
}
}
contract D is C {
function y() public returns (uint) {
iData = 3; // internal access
return iData;
}
function getResult() public view
returns(uint){
uint a = 1; // local variable
uint b = 2;
uint result = a + b;
return storedData; //access the state
variable
}
}

What is an Operator?
Let us take a simple expression 4 + 5 is equal to 9. Here 4 and 5 are called
operands and '+' is called the operator. Solidity supports the following types of
operators.
1. Arithmetic Operators
2. Comparison Operators
3. Logical (or Relational) Operators
4. Assignment Operators
5. Conditional (or ternary) Operators
Operators

Arithmetic Operators
Solidity supports the following arithmetic operators −
Assume variable A holds 10 and variable B holds 20, then −
1
+ (Addition)
Adds two operands
Ex: A + B will give 30
2
- (Subtraction)
Subtracts the second
operand from the first
Ex: A - B will give -10
3
* (Multiplication)
Multiply both operands
Ex: A * B will give 200

4
/ (Division)
Divide the numerator
by the denominator
Ex: B / A will give 2
5
% (Modulus)
Outputs the remainder of
an integer division
Ex: B % A will give 0
6
++ (Increment)
Increases an integer
value by one
Ex: A++ will give 11
7
-- (Decrement)
Decreases an integer
value by one
Ex: A-- will give 9

contract SolidityTest {
constructor() public{
}
function getResult() public view returns(uint){
uint a = 1;
uint b = 2;
uint result = a + b; //arithmetic operation
return result;
}
}

Comparison Operators
Solidity supports the following comparison operators −
Assume variable A holds 10 and variable B holds 20, then −
1
= = (Equal)
Checks if the value of two
operands are equal or not, if yes,
then the condition becomes true.
Ex: (A == B) is not true.
2
!= (Not Equal)
Checks if the value of two operands
are equal or not, if the values are not
equal, then the condition becomes
true.
Ex: (A != B) is true.

3
> (Greater than)
Checks if the value of the left operand is
greater than the value of the right operand,
if yes, then the condition becomes true.
Ex: (A > B) is not true.
5
>= (Greater than or Equal to)
greater than or equal to the value of the
right operand, if yes, then the condition
becomes true.
Ex: (A >= B) is not true
6
<= (Less than or Equal to)
Checks if the value of the left operand
is less than or equal to the value of the
right operand, if yes, then the condition
becomes true.
Ex: (A <= B) is true
4
< (Less than)
less than the value of the right operand,
if yes, then the condition becomes true.
Ex: (A < B) is true.

contract SolidityTest {
uint storedData;
constructor() public{
storedData = 10;
}
function getResult() public view returns(string memory){
uint a = 1; // local variable
uint b = 2;
uint result = a + b;
return integerToString(result);
}
function integerToString(uint _i) internal pure
returns (string memory _uintAsString) {

if (_i == 0) { //comparison operator
return "0";
}
uint j = _i;
uint len;
while (j != 0) { //comparison operator
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (_i != 0) {
bstr[k--] = byte(uint8(48 + _i % 10));
_i /= 10;
}
return string(bstr);//access local variable
}

Loops
While writing a contract, you may encounter a situation where you need to perform an
action over and over again.
In such situations, you would need to write loop statements to reduce the number of
lines.
Solidity supports all the necessary loops to ease down the pressure of programming.

1
While Loop
The most basic loop in Solidity is the while loop which would be discussed in this
chapter. Flow Chart:
The flow chart of while loop looks as follows

Syntax
The syntax of while loop in Solidity is as follows −
while (expression) {
Statement(s) to be executed if expression is true
}
pragma solidity =0.5.0 <= 0.9.0;
contract array
{
uint[3] public arr;
uint public count;
function loop() public{
while(count<arr.length)
{
arr[count] = count;
count++;
}
}
}

2
do...while Loop
The do...while loop is similar to the while loop except that the condition check happens
at the end of the loop.
Syntax
The syntax for do-while loop in
Solidity is as follows −
do {
Statement(s) to be executed;
} while (expression);

// Solidity program to
// demonstrate the use of
// 'Do-While loop'
// 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;
}
}

For Loop
The for loop is the most compact form of looping. It includes the following three important parts.
The loop initialization where we initialize our counter to a starting value. The initialization statement
is executed before the loop begins.
The test statement which will test if a given condition is true or not. If the condition is true, then the
code given inside the loop will be executed, otherwise the control will come out of the loop.
The iteration statement where you can increase or decrease your counter.

Syntax
The syntax of for loop is
Solidity is as follows −
for (initialization; test
condition; iteration
statement) {
Statement(s) to be
executed if test condition is
true
}

// demonstrate the use
// of 'For loop'
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;
}
}

1 if statement
The if statement is the fundamental control statement that allows Solidity to make
decisions and execute statements conditionally.
// demonstrate the
// use of 'if statement'
contract Types {
// Declaring state variable
uint i = 10;
// Defining function to
// demonstrate use of
// 'if statement'
function decision_making(
) public returns(bool){
if(i<10){
return true;
}
}
}

2 if...else statement
The 'if...else' statement is the next form of control statement that allows Solidity to
execute statements in a more controlled way.
// 'if...else' statement
contract Types {
// Declaring state variables
uint i = 10;
bool even;
//
Defining function to
// 'if...else statement'
) public payable returns(bool){
if(i%2 == 0){
even = true;
}
else{
even = false;
}
return even;
}
}

if...else if... statement.
The if...else if... statement is an advanced form of if...else that allows Solidity to make a correct
decision out of several conditions.
contract Types {
// Declaring state variables
uint i = 10;
string result;
// Defining function to
// demonstrate the use
// of 'if...else if...else
// statement'
) public returns(string memory){
if(i<10){
result = "less than 10";
}
else if(i == 10){
result = "equal to 10";
}
else{
result = "greater than 10";
}
return result;
}
}

Structs
Solidity enables users to create their own type in the form of Structure. The structure is the
group of different types although it is not possible to contain a member of its own type.
Structure is a reference type variable and can contain both - value types and reference types.
Declaration
struct <name of structure> {
<type> variable1;
<type> variable2;

contract Types {
struct User {
string name;
uint age;
bool isValid;
}
User _user = User("John", 40, true);
function getUserInfo()
public view
returns (string memory, uint,bool) {
return(_user.name, _user.age, _user.isValid);
}
}

Mapping Types
Mapping types are the most used reference type; they are used to store data in a key-value pair; where
the key can be any built-in value types or byte and string. You can think of it as a hash table or dictionary
as in any other language, in which a user can store data in a key-value format and data can be retrieved
by key.
mapping(_KeyType => _ValueType) <access specifier> <name>;
Example
mapping (address => uint) account;
contract MappingExample {
mapping(address => uint) account;
function updateBalance(uint newBalance) public {
account[msg.sender] = newBalance;
}
function getBalance(address _address)
public view returns (uint) {
return account[_address];
}
}

A function is a group of reusable code which can be called anywhere in your
program.
This eliminates the need of writing the same code again and again. It helps
programmers in writing modular codes.
Functions allow a programmer to divide a big program into a number of
small and manageable functions.
Like any other advanced programming language, Solidity also supports all
the features necessary to write modular code using functions.
This section explains how to write your own functions in Solidity.

Function Definition
Before we use a function, we need to define it.
The most common way to define a function in Solidity is by using the
function keyword, followed by a unique function name, a list of parameters
(that might be empty), and a statement block surrounded by curly braces.

Syntax
The basic syntax is shown here.
function function-name(parameter-list) scope
returns() {
//statements
}

Introduction
A programming language has an important aspect of taking decisions
in code.
Solidity delivers the if…else and switches statements to execute
different instructions based on circumstances.
This is too significant to loop through multiple items.
Solidity provides different constructs such as for loops and while
statements.

Solidity expressions
A statement, comprising multiple operands and optionally zero or
more operators is referred to as an expression.
That gives results in a single value, object, or function.
The operand may be a variable, literal, function invocation, or
another expression itself.

solidity programming.pptx

More Related Content

What's hot (20)

Similar to solidity programming.pptx (20)

Recently uploaded (20)

solidity programming.pptx