This is The Complete Solidity Notes With Code Snippest and Comments, Which Will Help You Understand Better
Before Writing Solidity Code, We Have To Include This Code Snippest
SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// 0.8.0 Refers to the Version of SolidtyLets Start
- Data Types Values Types
contract ValuesTypes {
bool public Item = true;
uint256 public UnsignedInt = 1000; // We Can Set int#. Here Hash Represent Any Number. 0 to 2^#-1
int256 public MyNum = 7000; // We Can Set int#. Here Hash Represent Any Number. 0 to 2^#-1
address public MyAddress=0x5B38Da6a701c568545dCfcB03FcB875f56beddC4; //Sture 20 Bit Adress. Store Hex Adress
bytes32 public MyBytes32;
}
- Solidity Functions
contract FunctionsInSolidity{
uint public Age=20;
function Add(uint X, uint Y) public pure returns(uint) {
return X+Y;
}
function GetAge() public view returns(uint) {
return Age;
}
function ChangeAge() public {
Age+=1;
}
function InternalFunction () internal {
// Code
}
}
function Outside(uint XYZ){
// I Can Be Declared Outside the Contract But My Button Cannot be Shown While Deploy
}- State Variable
contract StateVariable{
/*
In Solidity Variables are of 3 Types (State,Local,Global). But Today We Will Discuss Only State Variables
State Variables are Those That Are Declared Inside Contract, But They are Outside of Functions.
State Variables Are Important. Because They Cost Gas and They Are Directly Stored in Blockchain Storage. And There are only 3 Ways to
Initialise Them. 1) By Directly Initialising While Declaring. 2) By Constructor. 3) By Using Function.
*/
uint16 public MyStateVariable;
// MyStateVariable=1500; This is Not Allowed and Will Give Error
constructor(){
MyStateVariable=2000;
}
function SetVariable() public {
MyStateVariable=5000;
}
}- Local Variable
contract LocalVariable{
/*
Local Variable are Those That Are Declared or Intialized Inside Functions. They Stored Inside RAM and Have Short Life Span, Depends
on Life Cycle of Function. They also Cost Gas, But Very Negligible
*/
function DealLocalVariable() public pure returns (uint,bool) {
uint Age=12;
bool Status=false;
Age=20;
return (Age,Status);
}
}- Global Variable
contract GlobalVariable{
/*
These are Special Predefined Variables. No Need to Create. These Provide Info About
Blockchain and Transaction Properties
Variable Type Description
msg.sender address The address of the account that sent the current transaction.
msg.value uint The amount of Ether sent with the current transaction.
block.coinbase address The address of the miner who mined the current block.
block.difficulty uint The difficulty of the current block.
block.gaslimit uint The maximum amount of gas that can be used in the current block.
block.number uint The number of the current block.
block.timestamp uint The timestamp of the current block.
now uint An alias for block.timestamp.
tx.origin address The address of the account that originally created the transaction (i.e., the sender of the first transaction in the call chain).
tx.gasprice uint The gas price (in Wei) of the current transaction.
*/
address public MyAdress=msg.sender;
uint public Difficulty=block.difficulty;
uint public Cost=tx.gasprice;
uint public Time=block.timestamp;
}- View Pure and Simple
contract ViewPureSimple{
/*
Functions Are of Three Types 1) View 2) Pure and 3) Simple
1) View:- These Are Read Only Blockchain, State Variables and Global Variables. Never Update Them
2) Pure:- These Never Read and Update(Write) Blockchain, State Variables and Global Variables
3) Simple:- They Update the State Variable. No Neeed to Mention Simple Keyword. This Dont
Return Anything
*/
uint8 public Age=20;
function MyView() public view returns (uint) {
return Age+10;
}
function MyPureOne() public pure returns (uint){
return 1;
}
function MyPureTwo(uint X, uint Y) public pure returns (uint){
uint Sum=X+Y;
return Sum;
}
function MySimple() public returns(uint) {
Age+=23;
return Age;
}
}- Default Values
contract DefaultValues{
uint public X; // 0
bool public Status; // false
address public MyAdress; // 0x0000000000000000000000000000000000000000
bytes32 public MyBytes; // 0x0000000000000000000000000000000000000000000000000000000000000000
string public Name; // stirng
}- Strings in Solidity
contract MyString{
//State Variables Stored in Blockchain Storage, No Need to Declared Memory Keyword
string public Name="Muhammad Zubair";
/*
Becausse Functins and Local Variables Stored in Memory or Stack , That's Why We
Using Memory Keyword Inside Functions
*/
function GetAndSetString(string memory ArgName) pure public returns(string memory) {
// string memory Name="Zubair";
string memory MyName=ArgName;
return MyName;
}
}- Constants in Solidity
contract MyConstants{
// The Variable With Constant Keyword Will Cost Low Gas
address constant public MyAdressA=0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
// The Variable Without Constant Keyword Will Cost High Gas
address public MyAdressB=0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
}- Constructor in Solidity
contract Constructor{
uint public Age;
string public Name;
address public Owner;
// Constructor is the Functions That is Invoked Fitrst. If Not Defined. Constructor Defined It
// constructor(){
// Age=20;
// Name="Zubair";
// Owner=msg.sender;
// }
constructor(uint _Age, string memory _Name, address _Owner){
Age=_Age;
Name=_Name;
Owner=_Owner;
}
}- If Else in Solidity
contract IfElse{
/*
If Else Cannot Defined at Contract Level (Where State Variable Defined)
They Only Defined At Local Level
*/
function Check(uint Age) public pure returns(string memory){
string memory Message;
if(Age>100){
Message="Greater Than 100";
}
else if(Age<100){
Message="Less Than 100";
}
else{
Message="Equal 100 or Error";
}
return Message;
}
}- Ternary Operator in Solidity
contract Ternary {
function Check(uint Age) public pure returns(string memory){
string memory Message;
Message=Age>100?"Greater Than 100":"Less or Equal to 100";
return Message;
}
}- All Types of Loops in Solidity
contract MyLoops{
/*
Loops Also Don't Work at Contract Level Like Conditional Statement
You Should Be Carefull While Loops. They Can Cost
*/
function AllLoops() public pure returns(uint,uint,uint){
uint For;
uint While;
uint DoWhile;
for (uint I=0; I<10; I++)
{
For+=I;
}
uint J=0;
while (J<10)
{
While +=J;
J++;
}
uint K=0;
do{
DoWhile+=K;
K++;
} while(K<10);
return (For,While,DoWhile);
}
}- Continue and Break in Solidity
contract ContinueAndBreak {
function MyFunc() public pure returns (uint256) {
uint256 For;
for (uint256 I = 0; I < 10; I++) {
if (I < 8) {
continue;
}
For += I;
if (I == 8) {
break;
}
}
return For;
}
}- Fixed Size Array in Solidity
contract Array{
//Array Just Like Strings Stored on Blockchain Storage
uint[5] public OuterArray;
constructor(){
OuterArray=[1,2,3,4,5];
}
//This Function Will Cost Huge Gas
function GetArray() public view returns (uint[5] memory) {
return OuterArray;
}
function LocalFunc() public pure returns (uint) {
uint [] memory MyArra=new uint[](5);
MyArra[2]=23;
return MyArra[2];
}
function Mabipulate() public {
//Update Array
OuterArray[2]=23;
//Delete Element
delete OuterArray[3];
//Get Length
uint Length=OuterArray.length;
}
}- Dynamic Size Array in Solidity
contract DynamicArray {
/*
Dynamic Size Arrays Cannot Be Created In Memory. They Have Push and Pop Method. This Can be Initialized in Functio, Constructor
*/
uint256[] public OuterArray = [1, 2, 3, 4, 5, 6];
function GetArray() public view returns (uint256[] memory) {
return OuterArray;
}
// See We Cannot Create Dynamic Array in Memory
// function LocalFunc() public pure{
// uint256[] memory MyArra = new uint256[];
// }
function Manipulate() public {
// Update Array
OuterArray[2] = 23;
//Delete Element
delete OuterArray[3];
//Get Length
uint256 Length = OuterArray.length;
// Push Element At Last
OuterArray.push(100);
OuterArray.push(200);
OuterArray.push(300);
OuterArray.push(400);
// Pop Element From Last
OuterArray.pop();
}
}- Bytes (Fixed Size) in Solidity
contract MyFixedBytes{
/*
1) Bytes are Similar to Arrays, But They Stored Values in Hexadecimal
2) bytes#. Here # is any Number. If # is 5 Then It Will Create 5 Boxes
3) Each Box is of 1 Byte (8 Bit)
4) Each Box Contains 2 Hexadecimal Digits. So Each Digit 4 Bits
5) Data Types are of Two Types 1) Value 2) Refrence. Bhtes are Refrence Types
*/
bytes6 public Name; //Default 0x000000000000
bytes2 public Age; //Default 0x0000
function SetValues() public {
Name="Zubair"; //Store Like That 0x5a7562616972
Age="20"; //Store Like That 0x3230
}
function GetSize() public view returns (uint,uint){
return (Name.length, Age.length);
}
function GetEach(uint X) public view returns (bytes1,bytes1){
return (Name[X],Age[X]); //Answer is 6,2
}
}- Bytes (Dynamic Size) in Solidity
contract DynamicBytes{
bytes public Temp;
constructor(){
Temp="Muhamamd Zubair ";
}
function Push() public {
Temp.push('r');
}
function Pop() public {
Temp.pop();
}
function Length() view public returns (uint) {
return Temp.length;
}
function GetEach(uint ID) public view returns(bytes1){
return Temp[ID];
}
}- Enums in Solidity
contract Enums{
/*
1) These are User Defined Data Types
2) Used When We Have More Than 2 Choices Unlike Boolean
3) Can Be Used For Naming Convention For Integers
4) Increase Readability. Helps Easy Maintanance of Smart Contract
5)
*/
enum Status{
PENDING,
REJECTED,
SHIPPED,
ACCEPTED,
CANCEL
}
Status MyStatus; //This Have Default Value 0 (PENDING);
function SetStatus(Status ID /*ID Will Be A Number*/) public {
MyStatus=ID;
}
function SetReject() public {
MyStatus=Status.REJECTED;
}
function ResetStatus() public {
delete MyStatus; //This Will Again Set MyStatus to 0 (Pending)
}
function GetStatus() public view returns(Status) {
return MyStatus; //O or 1 or Else
}
}- Struct in Solidity
contract MyStruct{
/*
1) This is Another User Defined Refrence Type Data
2) Group of One or More In-Built Data Types
3) By Default Stored In Storage
4) Can Be Defined Inside or Outside Contract
5) If Declared Outside, Will Be Accessed By Multiple Contracts
*/
struct Employee{
string Name;
uint Age;
address Account;
}
Employee public Single;
Employee[] public Array;
constructor(uint _Age, string memory _Name, address _Acc){
Single.Name=_Name;
Single.Age=_Age;
Single.Account=_Acc;
}
function SetValues() public {
// Two Ways to Create Instance of IT
Employee memory E1=Employee("Zubair",20,msg.sender);
Employee memory E2=Employee({Name:"Talha",Age:20,Account:msg.sender});
Array.push(E1);
Array.push(E2);
}
function Manipulate() public returns (Employee memory,Employee memory){
// By Copy
Single=Array[1];
delete Array[1];
// This is Also By Copy. Changes In Temp Wont Reflect in Single
Employee memory Temp=Single;
Temp.Name="Kabeer";
// This is Also By Refrence. Changes In NewTemp Will Reflect in Single
Employee storage NewTemp=Single;
// NewTemp.Name="Kabeer Shah";
return (Temp,NewTemp);
}
}- Mapping & Advanced Mapping in Solidity
/*
1) Mapping (Key Value Pairs) is also a Data Type
2) They Connot be Declared at File Level and Function Level
3) Key Can Be of ENUM,Values, and Contract Types
*/
contract BasicMapiing {
mapping(uint256 => string) public Employee;
function SetValues() public {
Employee[15] = "Zubair";
Employee[16] = "Talha";
Employee[17] = "Kamran";
Employee[18] = "Naheed";
Employee[19] = "John";
}
function GetValues(uint256 ID) public view returns (string memory) {
return Employee[ID];
}
}
struct DonorInfo {
string Name;
uint256 Age;
string Addr;
uint256 Amount;
}
contract AdvanceMapping {
mapping(address => DonorInfo) public NGO;
function SetInfo(
string memory Name,
uint256 Age,
string memory Addr,
uint256 Amount
) public {
NGO[msg.sender] = DonorInfo(Name, Age, Addr, NGO[msg.sender].Amount+Amount);
}
function DeleteInfo(address Add) public {
delete NGO[Add];
}
}- Visibility in Solidity
contract Visibility {
/*
1) Visiblity Used By Function and State Variables
2) Who can Call or Access Function and State Variables
3) These Are of 4 Types 1) Public 2) Private 3) Internal 4) External
4) PotentialCaller of 4 Types
a) Inside Itself Contract
b) Derived Contract to His Parent Contract (Inheritence)
c) Another Contract (No Relation Between Contract, But In Same File)
d) Outside World (Buttons in Remix IDE)
Gas Order (Low to High) & Security(High to Low) => Private->Internal->External->Public
5) Private:- State Variablae (SV) and Function Accessed only Inside Contract
6) Internal:- Within Contract and Child Contract
7) External:- Only For Function (No SV). Not Allowed to Call for Derived and Contract Itself . Also Call in Outside World (Button in IDE)
8) Public:- Can Be Called by Any Potential Caller.
By Defaults SV Are Internal and Functions are Public
*/
uint256 private X = 1; // Only Within Contract
uint256 internal Y = 2; // Within Contract and Derived Contarct
uint256 public Z = 3; // EveryWhere
function CheckA() public pure returns (string memory) {
return "Public";
}
function CheckB() private pure returns (string memory) {
return "Private";
}
function CheckC() internal pure returns (string memory) {
return "Internal";
}
function CheckD() external pure returns (string memory) {
return "External";
}
function CheckAll() public pure returns (string memory) {
// return CheckA(); //Works
// return CheckC(); //Works
// return CheckB(); //Works
// return CheckD(); //Not Works
}
}
---
contract Child is Visibility {
string public ResultA = CheckA(); //It Works Result="Public"
// string public ResultB = CheckB(); //It Did'nt Works
string public ResultC = CheckC(); //It Works Result="Internal"
// string public ResultD = CheckD(); //It Did'nt Works
}
contract TempContract{
Visibility V1=new Visibility();
function External() public view returns(string memory) {
return V1.CheckD(); //Works
// return V1.CheckA(); // Works
// return V1.CheckB(); //Not Works
// return V1.CheckC(); //Not Works
}
}- Inheritence in Solidity
contract Inheritence {
// Virtual Keyword allows Child to Ovverride Its Implementation
function A() public pure returns (string memory) {
return "I am Inside A";
}
function B() public pure returns (string memory) {
return "I am Inside A";
}
function C() public pure virtual returns (string memory) {
return "I am Inside A";
}
function D() public pure virtual returns (string memory) {
return "I am Inside A";
}
}
contract Child is Inheritence {
function C() public pure override returns (string memory) {
return "I am Inside B";
}
function D() public pure virtual override returns (string memory) {
return "I am Inside B";
}
}
contract GrandChild is Child{
function D() public pure virtual override returns (string memory) {
return "I am Inside C";
}
}- Events and Indexing in Blockchain Solidity
contract Events {
/*
1) In Solidity, events are dispatched signals that smart contracts can fire. When you call events,
they cause the arguments to be stored in the transaction's log, which is a special data
structure in the blockchain.
2) Max Indexing Can be of 3 Variable
3) Placing the “indexed” keyword in front of a parameter name will store it as a topic in the log record.
Without the keyword “indexed”, it will be stored as data.
*/
event Alert(address Account,string Text, uint Balance);
// If You Want to Keep Indexing Below is The Method
// event Alert(address indexed Account,string indexed Text, uint indexed Balance, uint Extra);
function SetEvent(uint Val) public {
emit Alert(msg.sender, "Has Total Balance Of : ", Val);
}
}- Multiple Inharitance in Solidity
contract MultipleInheritence{
uint public A;
constructor(){
A=100;
}
function FunA() public {
}
}
contract Child is MultipleInheritence {
uint public B;
constructor (){
A=250;
B=500;
}
function FunB() public {
}
}
/*
Multiple Inheritence Order Is Frm Less Biased to More Biased.
It Canntot Be Child,MultipleInheritence. Dues To It Solve the
Diamond Problem and Cannot Have Duplicate Properties of Its
Parents. Preference is From Right to Left
*/
contract GrandChild is MultipleInheritence,Child{
}- Overriding in Multiple Inharitance in Solidity
contract Overriding{
uint public A;
constructor(){
A=1;
}
function Fun() public pure virtual returns(string memory) {
return "Hello From A";
}
}
contract Child is Overriding{
uint public B;
constructor(){
B=2;
}
function Fun() public pure override virtual returns(string memory) {
return "Hello From B";
}
}
contract GrandChild is Overriding,Child{
uint public C;
constructor(){
C=3;
}
// Due to Multiple Inheritence We Have to Use override(Child,Overriding). This is Mendatory
function Fun() public pure override(Child,Overriding) returns(string memory) {
return "Hello From C";
}
}- Passing Parameter to Parent Constructor in Multiple Inharitance in Solidity
contract A{
uint public Age;
string public Name;
constructor(uint _Age,string memory _Name){
Age=_Age;
Name=_Name;
}
}
contract B{
uint public Salary;
string public Adress;
constructor(uint _Salary,string memory _Adress){
Salary=_Salary;
Adress=_Adress;
}
}
//Following Are Ways to Passing Parameter to Parent Constructor in Multiple Inharitance
contract C is A(20,"Zubair"),B(100,"Lahore"){
}
//Order of Execution is A,B,D
contract D is A,B{
constructor() A(20,"Zubair") B(100,"Lahore"){
}
}
//Order of Execution is A,B,E
contract E is A,B{
constructor(uint _Age,string memory _Name,uint _Salary,string memory _Adress) A(_Age+10,_Name) B(_Salary*5,_Adress) {
}
}
//Order of Execution is A,B,F
contract F is A(20,"Talha"),B{
constructor(uint _Salary,string memory _Adress) B(_Salary*2,_Adress) {
}
}- Calling Parent Function in Multiple Inharitance in Solidity
// 1) By Direct Calling
// 2) By Super Method
contract A {
event Alert(string Message, uint256 Salary);
function Fun() public virtual {
emit Alert("A Has Salary : ", 500);
}
}
contract B is A {
function Fun() public override virtual {
emit Alert("B Has Salary : ", 600);
A.Fun(); // This is Called Direct Calling
super.Fun(); //This Can Also Call Parent
}
}
contract C is A,B {
function Fun() public override(A,B) {
emit Alert("C Has Salary : ", 700);
//This Will Check From Right to Left
super.Fun(); //This Can Also Call Parent
// This Will Print
/*
C Has Salary : , 700 //By C Contract
B Has Salary : , 600 //By B Contract
A Has Salary : , 500 //By B Contract
A Has Salary : , 500 //By A Contract
*/
}
}- Require in Solidity
contract Require{
/*
1) It is Used Fir Error Handling in Function
2) Used For Input Validation
3) Also Used For Acess Control
4) Also Refund Gas if Condition Get False
5) If Condition Get Fasle, Changes in State Variables By That Function also Reverted
and Statements After Require Wo'nt Be Executed
*/
uint public Age=20;
address Owner;
constructor(){
Owner=msg.sender;
}
function Check(uint X) public {
Age+=10;
require(X>5,"Values is Less < 5");
}
function OnlyOwner() public {
require(Owner==msg.sender,"Not Owner");
Age-=2;
}
}- Revert and Assert in Solidity
contract RevertAndAssert{
/*
1) Work Same as require(), But Condition is Given in IF-ELSE
2) Undo Also Works Same as require()
3) We Can Define Custom Error in Revert, Higher Error String Cost Higher Gas
4) To Check Bug and Security of Contract We Use Assert
5) If Found Bug Transaction Will Be Stopped
*/
uint public Age;
address Owner ;
constructor(){
Owner=msg.sender;
}
error CustomError(string,address); // Used For Custmom Error Handling
function Revert(uint Amount) public {
if(Amount<10){
// revert("Amount Lesser <10"); //Cost Hight Gas
Age+=5;
revert CustomError("Amount Lesser <10",msg.sender); //Cost Low Gass, Custom Error
}
}
function Assert() public {
assert(Owner==msg.sender);
Age+=5;
}
}- Function Modifiers in Solidity
contract MyContract {
/*
1) Modifier is Special Type of Function
2) Increase Reusability, Decrease Code Repeating
3) To Add Function Pre-Requisite
4) Can Be Multiple Modifiers in a Contract
*/
uint256 public Age = 0;
modifier RepeatedCode() {
for (uint256 I = 0; I < 10; I++) {
Age += I;
}
_; //This Means Go Back to Callee Function to Execute Remaining Code
}
modifier Check(uint256 Val) {
require(Age >= Val, "Less Than 10");
_;
}
function FunA() public RepeatedCode Check(45) {}
function FunB() public RepeatedCode Check(90) {}
function FunC() public RepeatedCode Check(135) {}
}- Payable in Solidity
contract MyContract{
/*
1) Payable is Ued to Make Adresses Payable
2) With This You Can Send Ethers to Those Adresses To Whom You Make Payable
3) If a Function is Payable Then Ethers Will be Added to That Contarct
In Which Function is Defined
4) Payable Function Can Be Pure and View Type
5) If Button Red then Payable, If Yellow Simple, If Blue Then View or Pure of SV;
6) A Payble function that can receive Ether and respond to an Ether deposit for
record-keeping purposes
7) 1Eth=10^18Wei
*/
// This State Variable is Payable
address payable public Adress=payable(msg.sender); //To Make Adress Payble ,We Have to Typecast
// This is How to Make Constructor Payble
constructor() payable {
}
// This Function is Payable
function ReceiveEther() payable public returns (string memory) {
return "Received Amount";
}
function CheckBalance() public view returns(uint) {
return address(this).balance; // Return address(this) Adress of Contract
}
}- Fallback and Receive in Solidity
contract FallbackAndReceive{
/*
A) Fallback
1) It is Executed When Non-Existence Func is Called on Contract
2) It is Required to Makred External
3) It Has No Name, No Argument, Not Return Anything
4) Can Be Defined One Per Contract
5) If Not Marked Payable, Will Throw Exception If Contarct Receives Ether
6) Main Usage is to Directly Send ETH to Contarct
7) Can Receive Data and Ether Both
B) Receive
1) It is Executed When Non-Existence Func is Called on Contract
2) It is Required to Makred External
3) It Has No Name, No Argument, Not Return Anything
4) Can Be Defined One Per Contract
5) If Not Marked Payable, Will Throw Exception If Contarct Receives Ether
6) Main Usage is to Directly Send ETH to Contarct
7) Can Receive Ether Only. Not Receive Data From Low Level Interaction
*/
event Alert(string Text,uint Amount);
// Use Low Interaction Button For Data Sending and Set Value Section for Sending Amount (Ether)
/*
First Deploy Contract and Then Set Value and Then Put Data in Low Level Interaction and
Click Trasact Button.
*/
fallback() external payable {
emit Alert("Fallback) Amount Received Is :", msg.value);
}
receive() external payable {
emit Alert("Receive) Amount Received Is :", msg.value);
}
function CheckBalance() public view returns (uint){
return address(this).balance;
}
}- Send Ether, Transfer, Call in Solidity
contract SendETH{
/*
1) Will Se How to Send Ether To Account or Another Contract
2) Three Method a) Send b) Trafser c) Call
a) Send:- Used to Trafser Ether to Adress of Account od Contarct. In Result Got Bool Value.
Has Limit of 2300 Gas. If Gas Cost >2300 Then Transaction Fail and Cost all Gas. Always Use
Require With It
b) Transfer:- Gas Limit of 2300. Nothing Get Returned. Changes in State Variable is Reverted.
No Need to Use Required.
c) Call:- We Ourself Decide Gas Limit. Get Bool Type Returned Value and Bytes (Having Some Data).
We Need to Use Require, Because It Dont Revert Changes as Send Function.
We Generally Use Call and Trafser. Highly Used is Call
*/
address payable public Receiver=payable (0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2);
receive() external payable {
}
function CheckBal() public view returns(uint){
return address(this).balance;
}
/*
For Below 4 Method We ave to First Transact Few Ethers to Our Contarct
Amount First Will Be Saved in This Contract and Then We Choose to Move From contract
to Receiver Acouont
*/
//Using Send Method
function SendContractToAdress() public {
bool Ans=Receiver.send(5000);
require(Ans,"Transaction Failed");
}
//Using Transfer Method
function TransferContractToAdress() public {
Receiver.transfer(5000);
}
//Using Call Method. Default Gas Limit is 3000000
function CallContractToAdress() public {
(bool Status,)=Receiver.call{value:500}("");
require(Status,"Transfer Failed");
}
//For Dynamic Adress
// function CallContractToAdress(address payable Receiver) public {
// (bool Status,)=Receiver.call{value:500}("");
// require(Status,"Transfer Failed");
// }
// ======================================================
/*
First Deploy, Then Select Value() Amount Ether and Then Call This Function and Input
Gette Account Adress
This is Direct Sending, Amount Move Directly From Function to Getter Account
*/
function DirectContractToAdress(address payable Getter) payable public {
(bool Status,)=Getter.call{value:msg.value}("");
require(Status,"Transfer Failed");
}
function DirectContractToContract(address payable Getter) payable public {
(bool Status,)=Getter.call{value:msg.value}("");
require(Status,"Transfer Failed");
}
}
/*
Now This is Illustraction of Sending Amount From Contarct to Contract
First Copies the ADress of Receiver Smart Contarct
*/
contract Sample{
function CheckBal() public view returns(uint){
return address(this).balance;
}
function DirectContractToContract(address payable Getter) payable public {
(bool Status,)=Getter.call{value:msg.value}("");
require(Status,"Transfer Failed");
}
}- Immutablity in Solidity
contract Immutablity{
/*
1) Immutable Transcation Cost Is High Than Constant
2) We Can Change Its Value at Two Places 1) Inline 2) At Deploy Time
3) Constants Are Initialized at Inline Only
4) If We Change Immuatable Variable Values in Any Function, It Wont Change
5) Cost Wise Order (Hight to Low) :- Simple->Immutable->Constant
*/
address public immutable OwnerA=msg.sender; //400 Gas
address public immutable OwnerB; //356 Gas. This Give Error, Can Be Resolve By Initializing it in Constructor
// address public constant C; //This Give Error, Asking to Intialize It Inline
address public constant OwnerC=address(1); //378 Gas
address public OwnerD=address(1); //2555 Gas
constructor(){
OwnerB=msg.sender;
}
}- Storage vs Calldata vs Memory in Solidity
contract Test {
/*
==Storage==
1) Storage Holds State Variables
2) Inside Blockchain
3) Cost High Gas
4) Data is Permanent
==Memory==
1) Memory Hold Local Variable
2) Data Not Permanent
3) Inside Mmeory or Stack
4) Also Cost Gas But Negligible
5) Function Inputs or Outputs are Also in Memory
==Calldata==
1) Aslo Inside Memory
2) Cost Low Gas
3) Data Inside Calldata Can Never Be Changed
4) Function Input Can Be Passed to Another Function as Input. Dont
Create Redundency
*/
uint256[] public Arr = [1, 2, 3, 4, 5];
// Data is Copied
function Storage() public {
uint256[] storage ARRS = Arr;
ARRS[1] = 1;
}
//Data is Pointing (Refered)
function Memory() public view {
uint256[] memory ARRM = Arr;
ARRM[1] = 1;
}
function TempMemory(string memory Name, uint256[] memory TempArr) public {
/*
Memory Type Data Can Be Passed to Memory Type Data, But Cannot
be Paased to Calldata
*/
TakeDataA(TempArr); //Works Fine
// TakeDataB(TempArr); //Will Cause Error
}
function CallData(string calldata Name, uint256[] calldata TempArr) public {
/*
Calldata Type Data Can Be Passed to Memory as well as Calldata
This Will Cause Very Low Gas, Because Calldata to Calldata
Does Not Create New Instance in Mmeory
*/
TakeDataA(TempArr); // Works Fine
TakeDataB(TempArr); // Works Fine
}
function TakeDataA(uint256[] memory TempArr) public {}
function TakeDataB(uint256[] calldata TempArr) public {}
}- Inbuilt Cryptographic Hash Function in Solidity
contract AllHash{
/*
Hashes are 1)SHA256, 2) Rimped160 3) Keccak256
1) SHA256:- Input Bytes , Output Hash 32 Bytes (Hugly Used)
1) Ripemd160:- Input Bytes, Ouput 20 Bytes
1) Keccak256:- Input Bytes , Output Hash 32 Bytes (Hugly Used)
These are Used in Cotract Signature and Creating ID
ABI encodes the given arguments. Arguments can be of any type.
It returns the encoded data as bytes
ABI encodePACKED the given arguments. Arguments can be of any type.
It returns the encoded data as bytes . But Different Byytes From ABI Encode
This Also Compress Bytes
*/
function KECCAK256(uint X, string memory Name, address Add) pure public returns (bytes32){
return keccak256(abi.encode(X,Name,Add));
// return keccak256(abi.encodePacked(X,Name,Add));
}
function SHA56(uint X, string memory Name, address Add) pure public returns (bytes32){
return sha256(abi.encode(X,Name,Add));
// return sha256(abi.encodePacked(X,Name,Add));
}
function RIPEMD160(uint X, string memory Name, address Add) pure public returns (bytes32){
return ripemd160(abi.encode(X,Name,Add));
// return ripemd160(abi.encodePacked(X,Name,Add));
}
}
MetaMask is a software cryptocurrency wallet used to interact with the Ethereum blockchain. It allows users to access their Ethereum wallet through a browser extension or mobile app, which can then be used to interact with decentralized applications
It is Used to 1) Store Ether 2) Send Ether 3) Receive Ether 4) Run Dapps 5) Swap Token
Rinkeby Faucet Help us to Generate Fake Ethers, That Has No Value
There are Various Environments in Remix IDE For Cntract Deployement
JVM) Javascript Virtual Machine 1) Transaction Exec in Sandbox 2) Own Memory blockchain 3) Ideal for Testing
Injected WEB3) 1) Deploy a Contract on Ethereum MainNet or TestNet
Web3 Provider) 1) Connect to a remote Node and Ethereum Client
When We Call a Setter Function It Creates Transaction that Needs to be Mined and Cost Gas Because IT Changes the Blockchain. But No Cost For Getter Function
Int Vs Uint 1) Integers are Signed Numbers 2) Uintegers are Unsigned Numbers
By Default Both Have Value 0
3) int Alias to int256
4) uint Alias to uint256
5) int8 to int 256
6) uint8 to uint256
7) int8 =-128 to 127 || uint8=0 to 255
8) int16 =-32768 to 32767 || uint16=0 to 65535
9) Formulaes:
int=-2^(n-1) to 2^(n-1)-1
uint=0 to 2^n-1
function createDynamicArray() external pure returns (uint256[] memory) {
uint256[] memory dynamicArray = new uint256[](1000);
// Populate the dynamic array with elements
dynamicArray[0] = 1;
dynamicArray[1] = 2;
dynamicArray[2] = 3;
dynamicArray[3] = 4;
dynamicArray[4] = 5;
return dynamicArray;
}In Fixed Size Bytes Arrays, Bytes Array Are Immutable. It Means We Cannot Change the Value at Any Index
