DEV Community: Muhammad Ayaz

Solidity Crash Course 🚀

Muhammad Ayaz — Sun, 02 Feb 2025 10:42:36 +0000

Welcome to the Solidity Crash Course series! This collection of tutorials will guide you through the basics of Solidity, from syntax to advanced concepts. Each part covers essential topics with examples to help you get started.

📜 Crash Course List

Solidity Crash Course - Part 01

Introduction to Solidity and setting up your environment.
Solidity Crash Course - Part 02

Understanding Solidity contract syntax and writing your first smart contract.
Solidity Crash Course - Part 03

Exploring variables, scopes, and abstract contracts.
Solidity Crash Course - Part 04

Comments, data types, if-else statements, and interfaces.
Solidity Crash Course - Part 05

Loops, events, arrays, and struct usage.
Solidity Crash Course - Part 06

Mappings, memory vs storage, and handling Ether.

🚀 How to Run Solidity in Remix IDE

Remix is an online Solidity compiler and IDE that allows you to write, deploy, and test smart contracts easily. Follow these steps to get started:

Open Remix IDE
- Visit Remix IDE in your web browser.
Create a New Solidity File
- In the File Explorer, create a new file. (Start with Blank Project)
- Name it with .sol extension (e.g., MyContract.sol).
Write Your Solidity Code
- Copy and paste your Solidity code into the newly created file.
Compile the Contract

Click on Play button at the TOP. OR
Go to the Solidity Compiler tab.
Select the Solidity version that matches your contract (usually defined in pragma solidity at the top of the file).
Click on Compile.

Stay tuned for more Solidity tutorials! Let me know if you have any questions or topics you'd like to see covered. 😊

Solidity Crash Course Series 🚀

Muhammad Ayaz — Sun, 02 Feb 2025 10:42:36 +0000

📜 Crash Course List

Solidity Crash Course - Part 01

Introduction to Solidity and setting up your environment.
Solidity Crash Course - Part 02

Understanding Solidity contract syntax and writing your first smart contract.
Solidity Crash Course - Part 03

Exploring variables, scopes, and abstract contracts.
Solidity Crash Course - Part 04

Comments, data types, if-else statements, and interfaces.
Solidity Crash Course - Part 05

Loops, events, arrays, and struct usage.
Solidity Crash Course - Part 06

Mappings, memory vs storage, and handling Ether.

🚀 How to Run Solidity in Remix IDE

Remix is an online Solidity compiler and IDE that allows you to write, deploy, and test smart contracts easily. Follow these steps to get started:

Open Remix IDE
- Visit Remix IDE in your web browser.
Create a New Solidity File
- In the File Explorer, create a new file. (Start with Blank Project)
- Name it with .sol extension (e.g., MyContract.sol).
Write Your Solidity Code
- Copy and paste your Solidity code into the newly created file.
Compile the Contract

Click on Play button at the TOP. OR
Go to the Solidity Compiler tab.
Select the Solidity version that matches your contract (usually defined in pragma solidity at the top of the file).
Click on Compile.

Stay tuned for more Solidity tutorials! Let me know if you have any questions or topics you'd like to see covered. 😊

Solidity Crash Course - Part 06: Mapping, Ether, Memory and Storage

Muhammad Ayaz — Sat, 01 Feb 2025 13:40:38 +0000

Solidity Crash Course - Part 06 🚀

Introduction 🎉

Welcome to part 06 of our Solidity crash course! In this section, we will explore some fundamental concepts in Solidity that will help you build more advanced smart contracts. We will cover:

✅ Solidity - Mapping
✅ Solidity - Memory vs Storage
✅ Solidity - Ether

By the end of this lesson, you’ll understand why these concepts are crucial and how to use them effectively. Let’s dive in! 🏊‍♂️

Solidity - Mapping 🗺️

Mappings in Solidity are like hash tables or dictionaries in other programming languages. They allow you to store key-value pairs efficiently.

Why Use Mappings?

Mappings are great for storing data that needs fast lookup, such as token balances or user permissions.

Example:

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

contract UserBalance {
    mapping(address => uint) public balances;

    function setBalance(uint _amount) public {
        balances[msg.sender] = _amount;
    }

    function getBalance(address _user) public view returns (uint) {
        return balances[_user];
    }
}

Best Use Case ✅

Storing user balances in a token contract
Keeping track of ownership or permissions

Solidity - Memory vs Storage 💾

In Solidity, memory and storage are used to manage data. But what’s the difference? 🤔

`storage` 📦 (Permanent)

Stored on the blockchain
Costs gas to modify
Used for persistent state variables

`memory` 🏃‍♂️ (Temporary)

Exists only during function execution
No gas cost for reading (only for writing)
Used for function arguments and temporary variables

Example:

contract DataExample {
    string[] public storageArray; // Stored on the blockchain

    function addToStorage(string memory _text) public {
        storageArray.push(_text); // Modifies state variable (costs gas)
    }

    function processMemory(string memory _text) public pure returns (string memory) {
        return _text; // Exists only during function execution
    }
}

Best Use Case ✅

Use storage for data that needs to persist (like user balances)
Use memory for temporary data (like function inputs)

Solidity - Ether 💰

Ether (ETH) is the native cryptocurrency of the Ethereum blockchain, and smart contracts can send, receive, and store Ether.

Sending & Receiving Ether

Smart contracts use special functions to handle Ether transactions.

Example:

contract EtherWallet {
    address payable public owner;

    constructor() {
        owner = payable(msg.sender);
    }

    // Receive Ether
    receive() external payable {}

    // Get contract balance
    function getBalance() public view returns (uint) {
        return address(this).balance;
    }

    // Withdraw Ether
    function withdraw(uint _amount) public {
        require(msg.sender == owner, "Not the owner");
        payable(msg.sender).transfer(_amount);
    }
}

Best Use Case ✅

Smart contracts that hold funds (like a wallet or crowdfunding contract)
Decentralized finance (DeFi) applications

Conclusion 🎯

In this part, we covered:
✅ Mappings and their importance in Solidity
✅ The difference between memory and storage
✅ How smart contracts handle Ether transactions

Let me know if you have any questions, comments, or feedback! 😊

Would love to help you out! 🚀

Solidity Crash Course - Part 05: While,For loop, Event, Arrays and Struct

Muhammad Ayaz — Sat, 01 Feb 2025 13:28:58 +0000

Solidity Crash Course - Part 05 🚀

Introduction 👋

Welcome back to our Solidity crash course! In this part, we'll cover some essential concepts to help you write more efficient and structured smart contracts. Let's dive in! 🏊‍♂️

Solidity - While Loops 🔄

Loops are used to execute a block of code multiple times based on a condition. A while loop continues to execute as long as the condition remains true.

Example:

pragma solidity ^0.8.0;

contract WhileLoopExample {
    uint public count;

    function countUp(uint _limit) public {
        while (count < _limit) {
            count++;
        }
    }
}

✅ Why use while loops?

Great for situations where you don’t know the exact number of iterations beforehand.

⚠️ Best Practice: Be cautious of infinite loops as they can waste gas and cause transactions to fail.

Solidity - Events 📢

Events allow smart contracts to communicate with external applications like dApps. They help log important actions that occur on the blockchain.

Example:

pragma solidity ^0.8.0;

contract EventExample {
    event NumberChanged(uint oldValue, uint newValue);
    uint public number;

    function updateNumber(uint _newValue) public {
        emit NumberChanged(number, _newValue);
        number = _newValue;
    }
}

✅ Why use events?

Efficiently store data without consuming unnecessary gas.
Helps external applications listen to changes.

⚠️ Best Practice: Use events to log only important updates to reduce gas costs.

Solidity - For Loops 🔁

A for loop is used when you know the number of iterations beforehand.

Example:

pragma solidity ^0.8.0;

contract ForLoopExample {
    uint[] public numbers;

    function fillArray(uint _limit) public {
        for (uint i = 0; i < _limit; i++) {
            numbers.push(i);
        }
    }
}

✅ Why use for loops?

Ideal when you need to iterate a known number of times.

⚠️ Best Practice: Avoid looping through large arrays to prevent exceeding gas limits.

Solidity - Arrays 📦

Arrays store multiple values in a single variable, allowing efficient data management.

Example:

pragma solidity ^0.8.0;

contract ArrayExample {
    uint[] public numbers;

    function addNumber(uint _num) public {
        numbers.push(_num);
    }

    function getNumber(uint index) public view returns (uint) {
        return numbers[index];
    }
}

✅ Why use arrays?

Efficient storage and retrieval of multiple data points.
Useful for managing lists like registered users or transaction records.

⚠️ Best Practice: Use mappings instead of arrays when searching for values frequently.

Solidity - Struct 🏗️

Structs allow you to create custom data types, grouping multiple properties together.

Example:

pragma solidity ^0.8.0;

contract StructExample {
    struct Person {
        string name;
        uint age;
    }

    Person public user;

    function setUser(string memory _name, uint _age) public {
        user = Person(_name, _age);
    }
}

✅ Why use structs?

Helps organize related data efficiently.
Useful for defining complex objects like user profiles or product details.

⚠️ Best Practice: Keep struct sizes minimal to optimize gas usage.

Conclusion 🎯

We covered essential Solidity concepts like loops, events, arrays, and structs. These are fundamental for writing more structured and efficient smart contracts.

Let me know if you have any questions, comments, or feedback! Would love to help you out! 😊

Solidity Crash Course - Part 4: Comments, Data Types, If-else, Interface

Muhammad Ayaz — Sat, 01 Feb 2025 13:15:18 +0000

Solidity Crash Course - Part 04 🚀

Welcome to Part 04 of our Solidity Crash Course! In this section, we will cover essential Solidity concepts, including comments, data types, the classic "Hello World" contract, conditional statements, and interfaces. Let's dive in! 🎉

📝 Solidity - Comments

Comments are essential in programming to make your code more readable and maintainable. Solidity supports two types of comments:

📌 Single-line comments

Use // to write a single-line comment.

// This is a single-line comment
uint public myNumber = 10; // Variable declaration

📌 Multi-line comments

Use /* ... */ for multi-line comments.

/*
This is a multi-line comment.
It can span multiple lines.
*/
contract MyContract {
    // Your code here
}

Why use comments?

Explain complex logic.
Improve code readability.
Help future developers understand the purpose of the code.

🔢 Solidity - Data Types

Solidity provides various data types to store different types of information.

📌 Integer Types (uint, int)

Used for storing numbers.

uint256 public positiveNumber = 100; // Unsigned integer (0 and above)
int256 public negativeNumber = -50;  // Signed integer (can be negative)

📌 Boolean

Stores true or false values.

bool public isActive = true;

📌 Address

Stores Ethereum addresses.

address public owner = msg.sender; // Stores the address of the contract deployer

📌 String

Used for storing text.

string public message = "Hello, Blockchain!";

📌 Arrays

Stores multiple values of the same type.

uint[] public numbers = [1, 2, 3, 4, 5];

Best Use Cases:

Integers for calculations.
Booleans for conditional logic.
Addresses for storing Ethereum users.
Strings for storing messages.
Arrays for lists of data.

🔄 Solidity - if-else

Conditional statements help in decision-making.

contract ConditionCheck {
    function checkNumber(uint _num) public pure returns (string memory) {
        if (_num > 10) {
            return "Greater than 10";
        } else if (_num == 10) {
            return "Equal to 10";
        } else {
            return "Less than 10";
        }
    }
}

Best Use Cases:

Validating inputs.
Implementing game rules.
Controlling smart contract logic.

🔌 Solidity - Interface

Interfaces allow interaction with other contracts without accessing their full code.

interface IExample {
    function getValue() external view returns (uint);
}

contract Caller {
    function fetchValue(address _contract) public view returns (uint) {
        return IExample(_contract).getValue();
    }
}

Why use interfaces?

Enables modularity.
Allows interaction with external contracts.
Reduces dependency on contract implementation.

🎯 Conclusion

In this part, we covered:
✅ Comments to improve code readability.
✅ Data types to store values.
✅ If-else for decision-making.
✅ Interfaces for interacting with other contracts.

Stay tuned for Part 05! 🚀

Let me know if you have any questions, comments or feedback!

Would love to help you out!

Solidity Crash Course - Part 03 : Variables, Scopes, Abstract contracts

Muhammad Ayaz — Sat, 01 Feb 2025 12:46:23 +0000

Solidity Crash Course - Part 03 🚀

Introduction

Welcome back to our Solidity crash course! In this part, we’ll explore variables, variable scopes, and abstract contracts. Understanding these concepts will help you write more efficient and secure smart contracts. Let’s dive in! 😃

Solidity - Variables 📌

What are Variables?

Variables in Solidity are used to store data on the blockchain or within a smart contract’s execution context. Solidity provides different types of variables to handle various data efficiently.

Example of Variables

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

contract VariablesExample {
    uint256 public myNumber = 42; // State variable
    string public myText = "Hello, Solidity!";
    bool public isActive = true;
}

Why do we need variables?

🔹 Store information like user balances, contract state, or configurations.
🔹 Improve code reusability by using values dynamically instead of hardcoding.
🔹 Enable contract interactions by letting users modify and retrieve stored data.

Best Use Case

Use variables to store important contract data like token balances, user addresses, or contract states.

Solidity - Variable Scopes 🌍

What is Variable Scope?

Variable scope determines where a variable can be accessed within a contract. Solidity has three main types of variable scopes:

State Variables – Stored permanently on the blockchain.
Local Variables – Exist only within a function and disappear after execution.
Global Variables – Provide blockchain-related information (e.g., sender address, block timestamp).

Example of Variable Scopes

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

contract ScopeExample {
    uint256 public stateVar = 100; // State Variable

    function localExample() public pure returns (uint256) {
        uint256 localVar = 50; // Local Variable
        return localVar;
    }

    function globalExample() public view returns (address) {
        return msg.sender; // Global Variable
    }
}

Why do we need variable scopes?

🔹 Security & Optimization – Limiting access to variables prevents accidental or malicious modifications.
🔹 Gas Efficiency – Local variables use less gas than state variables since they are not stored on-chain.
🔹 Better Code Structure – Proper scoping improves code readability and maintainability.

Best Use Case

Use state variables for permanent data storage, local variables for temporary calculations, and global variables for retrieving blockchain-specific details.

Solidity - Abstract Contracts 🎭

What is an Abstract Contract?

An abstract contract is a contract that contains at least one function without an implementation. It cannot be deployed on its own but acts as a blueprint for other contracts to inherit from.

Example of an Abstract Contract

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

abstract contract Animal {
    function makeSound() public virtual returns (string memory);
}

contract Dog is Animal {
    function makeSound() public pure override returns (string memory) {
        return "Woof!";
    }
}

Why do we need abstract contracts?

🔹 Code Reusability – Define a common structure for multiple contracts.
🔹 Enforcement of Standards – Ensures child contracts implement necessary functions.
🔹 Better Organization – Keeps smart contract development modular and clean.

Best Use Case

Use abstract contracts when you want different contracts to follow a common interface but allow them to implement their own logic.

Conclusion 🎉

In this part, we covered:
✅ Variables and how they store data.
✅ Variable scopes and their importance.
✅ Abstract contracts for defining contract templates.

Stay tuned for more Solidity learning! 🚀

Solidity Crash Course - Part 02: Smart Contracts

Muhammad Ayaz — Wed, 29 Jan 2025 13:46:19 +0000

Solidity Crash Course - Part 02

Introduction

Solidity is a high-level programming language used for writing smart contracts on the Ethereum blockchain. It is influenced by JavaScript, Python, and C++. In this part of the crash course, we will cover the basic syntax of Solidity contracts and how to write a smart contract.

How to Compile your Code

For compiling, easiest way is to goto Remix IDE, and paste your code and compile it. It comes with build in features for compiling and other useful tools. It also has templates if you want to experiment with different smart contracts.

Solidity - Contract Syntax

A Solidity contract is a collection of code (functions) and data (state) that resides at a specific address on the Ethereum blockchain. Every Solidity contract starts with a version pragma, which specifies the compiler version.

1. Basic Structure of a Solidity Contract

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

contract MyFirstContract {
    // State variables
    uint public myNumber;
    string public myString;

    // Constructor - Runs only once when the contract is deployed
    constructor(uint _myNumber, string memory _myString) {
        myNumber = _myNumber;
        myString = _myString;
    }

    // Function to update number
    function setNumber(uint _newNumber) public {
        myNumber = _newNumber;
    }

    // Function to update string
    function setString(string memory _newString) public {
        myString = _newString;
    }
}

Breakdown of Code

SPDX-License-Identifier - This specifies the license for the contract.
Pragma directive - It ensures that the contract compiles with Solidity version 0.8.0 or later.
Contract declaration - The contract MyFirstContract {} defines the contract.
State Variables - uint and string variables store persistent data on the blockchain.
Constructor - Initializes the contract's state when deployed.
Public Functions - Functions setNumber and setString modify the contract's state.

Solidity - Smart Contract

A smart contract is a self-executing contract with predefined rules. Once deployed, it interacts with users and other contracts.

2. Writing a Simple Smart Contract

Below is an example of a smart contract that allows users to store and retrieve their favorite number.

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

contract FavoriteNumber {
    uint private favoriteNumber;

    // Event to notify when a number is changed
    event NumberUpdated(uint newNumber);

    // Function to set favorite number
    function setFavoriteNumber(uint _number) public {
        favoriteNumber = _number;
        emit NumberUpdated(_number);
    }

    // Function to get favorite number
    function getFavoriteNumber() public view returns (uint) {
        return favoriteNumber;
    }
}

Explanation

Events - Used to log contract interactions on the blockchain.
Public Function setFavoriteNumber - Allows users to store a number.
View Function getFavoriteNumber - Retrieves stored number without modifying the blockchain.
Emit Statement - Logs an event when the number is updated.

Deploying the Contract

To deploy the contract, you can use Remix IDE or Hardhat.

Deploying Using Remix IDE

Go to Remix IDE.
Copy and paste the Solidity contract into a new file (FavoriteNumber.sol).
Compile the contract using the Solidity compiler.
Deploy it using the Injected Web3 environment (MetaMask required).
Interact with the contract using the deployed functions.

If you need any help with deployment, let me know!

Conclusion

In this part, we covered the basic Solidity contract syntax and created a simple smart contract.

Stay tuned for Part 03!

Solidity Crash Course - Part 1: Basics and Pre Requisite

Muhammad Ayaz — Wed, 29 Jan 2025 11:13:02 +0000

Solidity Crash Course - Part 1: Basics

🚀 Welcome to Part 1 of the Solidity Crash Course! This guide covers the fundamentals of Solidity, Blockchain, Transactions, Gas, and the Ethereum Virtual Machine (EVM).

📌 What is Blockchain?

A blockchain is a decentralized, immutable ledger that records transactions securely. It consists of blocks, each containing a list of transactions, linked together to form a chain.

🔹 Key Features of Blockchain:

Decentralization → No central authority controls it.
Immutability → Transactions cannot be altered once recorded.
Transparency → Anyone can verify transactions.
Security → Cryptographic techniques ensure data integrity.

💳 Transactions in Blockchain

A transaction is a transfer of value or data on the blockchain. In Ethereum, transactions can be:

Ether Transfers → Sending ETH between accounts.
Contract Interactions → Calling functions in smart contracts.

✨ Example: Basic Transaction Structure

{
  "from": "0xSenderAddress",
  "to": "0xReceiverAddress",
  "value": "1000000000000000000", // 1 ETH in Wei
  "gas": "21000",
  "gasPrice": "5000000000"
}

🔍 Transaction Components:

From & To → Sender and recipient addresses.
Value → Amount of Ether sent.
Gas & Gas Price → Cost of execution.

⛽ Understanding Gas in Ethereum

Ethereum requires gas to execute transactions and smart contracts. Gas is a measure of computational effort.

🔥 Why Gas is Important:

Prevents spam → Users must pay to use the network.
Compensates miners → Incentivizes validation of transactions.
Manages network load → More complex operations require more gas.

🏷️ Example: Estimating Gas

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

contract GasExample {
    uint256 public value;

    function setValue(uint256 _value) public {
        value = _value; // Simple operation → Low gas cost
    }
}

🖥️ Ethereum Virtual Machine (EVM) Basics

The Ethereum Virtual Machine (EVM) is the runtime environment for executing smart contracts. It ensures security and decentralization.

🛠 Key Features of EVM:

Isolation → Contracts run independently from each other.
State Management → Keeps track of all accounts and balances.
Smart Contract Execution → Runs Solidity bytecode efficiently.

🎯 Summary

✅ Blockchain is a decentralized ledger for recording transactions.
✅ Transactions involve sending ETH or calling smart contracts.
✅ Gas is used to pay for computation and secure the network.
✅ EVM enables smart contract execution in a secure environment.

🔥 Next Steps

In Part #2, we’ll cover Smart Contracts. Stay tuned! 🚀

💬 Found this helpful? Drop a comment and share your first transaction experience!

Making forms easier with react-hook-form

Muhammad Ayaz — Sun, 02 Jan 2022 03:55:34 +0000

In this article, we will see how we can improve our developer experience and time while working with forms by using react-hook-form.

There are many libraries that facilitate working with forms making it easier to write and validate inputs

const { register, handleSubmit, watch, formState: { errors } } = useForm();

In order to use it, we have to call useForm hook. This will give properties that can we use in our code.

register will register your input element for validation and management
handleSubmit will handle your form submission
watch will constantly watch an element change
formState will give you the state of the form

<form onSubmit={handleSubmit(onSubmit)}>

handleSubmit will submit your form. Before submitting your form it will check for errors. If errors are found it will not proceed until all of the errors have been resolved.

<input placeholder="Jhon Doe" {...register('name')} />

We have defined the input element and registered it as name for validation.

<input
          placeholder="25"
          {...register('age', { required: true })}
          type="number"
        />

With registering we have also applied validation that this input is required.

<input
          type="number"
          {...register('experience', { min: 4 })}
          placeholder="4"
        />

input will not accept values that are under 4

<input
          type="number"
          {...register('experience', { max: 4 })}
          placeholder="4"
        />

Similarly, input will not accept values above 4

Suppose if you want to limit user for text length, you would do by

<textarea rows="4" cols="20" {...register('bio', {
          maxLength: 200
        })}

It will limit users to a maximum of 200 characters

Ok! Now we know how validation works but what is watch.

watch will constantly check for input values
Suppose if you want to monitor textarea in real-time, you might need to watch it and inform users that they have entered a certain words.

  let bio = watch('bio');
  console.log(bio);

  if (bio && bio.includes('ice')) {
    alert('You have written ice');
  }

.includes is a method on string. It will check if characters are involved in string

In order to inform users about the errors, we would have to refer to the errors object.

Let's recall

<div>
        <label htmlFor="bio">Bio</label>
        <br />
        <textarea
          rows="4"
          cols="20"
          {...register('bio', {
            maxLength: 30,
          })}
        />
        {errors.bio && <h4>Your bio have exceeded beyond 30 characters</h4>}
      </div>

If the maximum length of textarea exceeds 30 characters, it will give an error.

I hope you liked this article, if you have any questions/feedback feel free to ask me!

You can find the code here!
Code: https://stackblitz.com/edit/react-mpegjv?file=src/App.js

DEV Community: Muhammad Ayaz

Solidity Crash Course 🚀

📜 Crash Course List

🚀 How to Run Solidity in Remix IDE

Solidity Crash Course Series 🚀

📜 Crash Course List

🚀 How to Run Solidity in Remix IDE

Solidity Crash Course - Part 06: Mapping, Ether, Memory and Storage

Solidity Crash Course - Part 06 🚀

Introduction 🎉

Solidity - Mapping 🗺️

Why Use Mappings?

Example:

Best Use Case ✅

Solidity - Memory vs Storage 💾

storage 📦 (Permanent)

memory 🏃‍♂️ (Temporary)

Example:

Best Use Case ✅

Solidity - Ether 💰

Sending & Receiving Ether

Example:

Best Use Case ✅

Conclusion 🎯

Solidity Crash Course - Part 05: While,For loop, Event, Arrays and Struct

Solidity Crash Course - Part 05 🚀

Introduction 👋

Solidity - While Loops 🔄

Example:

Solidity - Events 📢

Example:

Solidity - For Loops 🔁

Example:

Solidity - Arrays 📦

Example:

Solidity - Struct 🏗️

Example:

Conclusion 🎯

Solidity Crash Course - Part 4: Comments, Data Types, If-else, Interface

Solidity Crash Course - Part 04 🚀

📝 Solidity - Comments

📌 Single-line comments

📌 Multi-line comments

🔢 Solidity - Data Types

📌 Integer Types (uint, int)

📌 Boolean

📌 Address

📌 String

📌 Arrays

🔄 Solidity - if-else

🔌 Solidity - Interface

🎯 Conclusion

Solidity Crash Course - Part 03 : Variables, Scopes, Abstract contracts

Solidity Crash Course - Part 03 🚀

Introduction

Solidity - Variables 📌

What are Variables?

Example of Variables

Why do we need variables?

Best Use Case

Solidity - Variable Scopes 🌍

What is Variable Scope?

Example of Variable Scopes

Why do we need variable scopes?

Best Use Case

Solidity - Abstract Contracts 🎭

What is an Abstract Contract?

Example of an Abstract Contract

Why do we need abstract contracts?

Best Use Case

Conclusion 🎉

Solidity Crash Course - Part 02: Smart Contracts

Solidity Crash Course - Part 02

Introduction

How to Compile your Code

Solidity - Contract Syntax

1. Basic Structure of a Solidity Contract

Breakdown of Code

Solidity - Smart Contract

2. Writing a Simple Smart Contract

`storage` 📦 (Permanent)

`memory` 🏃‍♂️ (Temporary)