What are Solidity Modifiers and How do they boost the security of Smart Contracts?

Introduction

Hello friends, I welcome you to the world of smart contracts and blockchain. In the world of blockchain development, Solidity serves as the bridge, turning new ideas into smart contracts, with modifiers acting as indispensable tools that refine and enhance the functionality of these contracts. In this article, we'll explore Solidity modifiers—a powerful tool to enhance our code. Think of them as handy upgrades for our functions, boosting security, simplifying code, and making it ready for reuse. Whether it's someone new to coding or a seasoned developer, this article has something for everyone. So, let's dive in and take a look at solidity modifiers.

What are Solidity Modifiers?

Modifiers in Solidity might sound complex, but let's break them down in simple terms. We can define modifiers as a set of instructions that we can add to a function in a smart contract. These instructions tell the function to do something specific before or after its usual job. It adds a few extra lines of code before or after a function's execution without actually adding the code snippet. Coders generally use these lines of code for checking several validations.

So, why do we need modifiers? It's because they make our smart contracts smarter. They help us add extra conditions or tasks to functions outside the function without messing up the whole function.

Basic Syntax

In Solidity, we start with the word "modifier," followed by a name for our modifier. Then, inside curly braces, we write the special instructions.

modifier modifier_name{
    // SPECIAL INSTRUCTIONS (BODY OF THE MODIFIER)
}

How Modifiers Enhance Functionality

Let's take an example where you are creating an ERC20 token smart contract with functionality like Burn, using which you can destroy a certain amount of tokens whenever the burn is required to control inflation. But, you don't want just any user to execute or call this burn function and only want the contract owner to call this function. Thus, making it an Admin functionality. You can do so by creating a modifier to check the contract owner and then executing the rest of the code if the condition is satisfied. The code would be like.

modifier onlyOwner {
    require(msg.sender == owner);
    _;  // This is like saying, "Okay, now do the function execution."
}

Now we can use this modifier in the function that we need only the contract owner to call. To do so, we need to include the modifier name in the function declaration.

function burn(uint256 _burnAmount) onlyOwner public {
    // Implementation of the burn functionality
}

You may ask, can't we add the check just at the top of the function body? Well, yes, you can, but by using a modifier we have reused the owner check, and now we can include this modifier to any function, and all we need to do is write the modifier name in the function declaration. If you haven't used the modifier, then you need to include the owner check line every time inside every function in which you only want the owner to be able to execute the function. This will increase the code size and will even cost us a higher gas fee while deploying the contract.

How does the _; Symbol works inside the modifier?

The _; symbol is a special symbol that you will find and include inside every modifier. This symbol is used in Solidity modifiers to mark the end of the modifier and the beginning of the function execution of the function that the modifier is modifying.

modifier onlyOwner {
    require(msg.sender == owner);
    _;  // Marks the end of the modifier and beginning of the function execution
}

Without the _; symbol to mark the end of the modifier and the beginning of the function, the compiler would not know where to insert the code from the modifier to the function.

Built-in Modifiers in Solidity

In Solidity, there are some built-in modifiers that are like pre-made tools for smart contract developers. Think of them as code that is ready to be used and makes our coding process smoother. Let's take a look at these modifiers.

1. View Modifier

The view modifier is used to indicate a view function. View functions in solidity are used to retrieve and view data or state variables stored in the blockchain contract but are not allowed to change the state of the contract, i.e., they are not allowed to modify the state variables. When we mark a function with a view modifier, then we say that the marked function will be a view function and not affect the state change. Thus, it won't cost gas fees to call the function.

For example

function checkBalance() public view returns (uint) {
    return myBalance;
}

2. Pure Modifier

The pure modifier is used to indicate a pure function. A pure function extends the functionality of the view function, where the view function says that it will only view and change the state of the contract. The pure function states that it will neither change the state of the contract nor it will view the state variables of the contract. The pure function is like a stand-alone function which is independent of the contract variables.

For example

function addNumbers(uint a, uint b) public pure returns (uint) {
    return a + b;
}

This addNumbers function is independent of the variables. It just adds the numbers provided to it as arguments and returns the result. Thus this add function is independent of any variable declared in the contract, thus making it a pure function, This pure function is identified and checked in solidity using the pure modifier.

3. Payable Modifier

The payable modifier simply tells a function that "We accept money here!". Unlike view and pure, a function marked as payable can receive and manage funds, making it crucial for transactions involving cryptocurrency.

For example

function receiveFunds() public payable {
    myBalance += msg.value;
}

In this example, we are specifying the receiveFunds function that can receive any amount of ether sent to it during the function call. In this function, when someone sends Ether to this function, the msg.value captures how much was sent, and myBalance is updated accordingly.

How to create Custom Modifiers?

Creating our own modifier is an easy task. We just need to take care of some simple things while creating our modifiers. Let's take an example, we are building a simple voting system on the blockchain and want to ensure that only eligible voters can cast their votes. A custom modifier will help us achieve this. Follow these steps:

Step 1. Think About the Condition

Consider the condition that you want to enforce. In our case, it's whether a voter is eligible or not.

Step 2. Start with the Modifier Keyword

Begin your modifier with the keyword "modifier." This keyword is always used to define a modifier. This tells Solidity that a modifier is being created.

modifier onlyEligibleVoter(address voter) {}

Step 3. Define the Condition

Use the "require" statement to set the condition. If the condition is satisfied, the function using this modifier will proceed; otherwise, it will stop.

require(isEligible(voter), "Not an eligible voter");

Here, isEligible is a function that is created to check if a voter is eligible or not. We'll get to that shortly.

Step 4. Add the Symbol _;

Now, add "_;" after the "require" statement. This symbol connects our modifier to the function that we'll use it with.

_;

Step 5. Create the Eligibility Checker Function

Now, create the isEligible function to check if a voter is eligible. This is where you define your eligibility criteria.

function isEligible(address voter) internal view returns (bool) {
    // Your eligibility criteria here
}

Remember to keep it simple for now. You can later make it more complex based on your project's requirements.

And with this, your modifier is completed. The entire code for the modifier would look like this.

modifier onlyEligibleVoter(address voter) {
      require(isEligible(voter), "Not an eligible voter");
      _;
} 

function isEligible(address voter) internal view returns (bool) {
    // Your eligibility criteria here
}

Now that we have our custom modifier, let's use it in a simple function. Imagine this function allows a voter to cast their vote.

function castVote(uint256 candidateId) public onlyEligibleVoter(msg.sender) {
    // Code to cast the vote
}

Here

• castVote is your voting function.
• onlyEligibleVoter is your custom modifier, ensuring only eligible voters can cast their votes.

Advanced Modifier Implementations

Modifiers can be used for a number of cases. Some of the advanced implementations include modifiers checking for reentrancy attacks and for gas optimization. Let's take a look at how we can create such modifiers.

Modifier protecting Reetrancy attack

Reentrancy is a situation where a function within a smart contract can be called repeatedly before it finishes executing.

To illustrate this, let's consider a scenario where a function in your contract transfers funds to another address. Without proper protection, an external party could exploit this function, repeatedly triggering the fund transfer while the process is still ongoing. This looping behavior can lead to unexpected and potentially harmful outcomes.

This is where modifiers come to the rescue. Modifiers are like a guide that ensures that once a function is in progress, it won't be called again until it completes its journey.

Let's look at a simple modifier that can help us to prevent reentrancy attacks.

// Modifier to prevent reentrancy
bool locked;

modifier noReentrancy {
    require(!locked, "Reentrancy detected");
    locked = true;
    _;
    locked = false;
}

function transferFunds(address to, uint amount) noReentrancy public {
    // Transfer funds logic
    // ...
}

Here, the noReentrancy modifier acts as a checkpoint. Once a function with this modifier is called, it sets a lock (locked) to prevent reentrancy until the function completes its execution. This ensures a smooth execution of the function without getting stuck in any kind of loop.

Modifier for Gas Optimization

Gas is just like fuel for our smart contract. In a blockchain environment, every time a user modifies the state of the blockchain, a certain amount of fee is required to be paid by that user to the network, which is called a gas fee. Our contract relies on gas to execute its functions. Thus, it should be ensured that a sufficient amount of gas is supplied during the time of execution. To do so, we can create a modifier that checks the gas available before any function execution, and if that is above a threshold, then allows the function execution.

Let's look at the gas optimization modifier.

// Modifier designed for gas optimization
modifier efficientGasUsage {
    require(gasleft() > 100000, "Insufficient gas");
    _;
}

function performGasEfficientTask() efficientGasUsage public {
    // Logic for gas-efficient task
    // ...
}

In this example, the efficientGasUsage modifier verifies if there's sufficient gas remaining before permitting the function's execution.

Modifiers with Arguments and Enum-based Modifiers

In this section, we'll dive into the world of modifiers with arguments and explore the functionality of enum-based modifiers. These features might sound a bit technical, but we'll break them down into simple terms.

Modifiers with Arguments

If you have heard about functions with arguments and used them in any programming language, then you will easily understand this topic. Modifiers with arguments are just exactly what they sound like, just like a function with arguments. They are just like normal modifiers. The difference is just that they are accepting some arguments as their argument list. Let's take a look at how a modifier with arguments is defined and used.

mapping(address => bool) private allowedAddress;

modifier onlyAllowedUser(address user) {
    require(allowedAddress[user], "Unauthorized user");
    _;
}

function addNewUser(address userAddress, string memory userName)public onlyAllowedUser(msg.sender) {
    // function logic
}

Here, onlyAllowedUser is a modifier that takes an address as an argument. It ensures that only the specified user can execute the associated function.

Creating an ENUM-based Modifier

Enums are like remotes with a limited number of operations. Let's take an example of how we can use enums in modifiers.

enum ActionType {
    CREATE,
    UPDATE,
    DELETE
}

modifier onlyAllowedAction(ActionType action) {
    require(action == ActionType.CREATE || action == ActionType.UPDATE, "Invalid action");
    _;
}

In this example, onlyAllowedAction ensures that the function that modifies can only be executed for actions like creating or updating. It's like choosing actions from a menu – only certain choices are valid.

To use this, we use the modifier with a function like.

function updateData(uint id, bytes32 newData, address user, ActionType action) onlyAllowedAction(action) public {
    // function body
}

Here, updateData function can only allow the user to perform the authorized actions.

Best Practices and Tips

Some of the best practices and tips while using modifiers inside a smart contract are as follows:

1. Keep It Simple: Aim for simplicity when creating modifiers. Clear and straightforward modifiers make code more understandable for everyone.
2. Single Responsibility: Assign a single responsibility to each modifier. This enhances code readability by isolating specific functionalities.
3. Avoid Overcomplexity: Steer clear of overly complex modifiers. Simplicity often translates to better code maintenance.
4. Clear Naming: Use descriptive and clear names for your modifiers. A well-named modifier is like a mini-documentation.
5. Comments Matter: Add comments to explain the purpose of your modifiers. A few words can save hours of confusion down the road.
6. Readable Formatting: Maintain consistent formatting. Well-organized code is easier to read and comprehend.
7. Logical Order: Arrange modifiers logically. Placing them in a logical order makes the code flow more intuitively.
8. Test Thoroughly: Rigorously test functions with combined modifiers. Ensuring they work seamlessly in all scenarios is essential.

Conclusion

In conclusion, Solidity modifiers emerge as essential companions in the realm of smart contract development, offering a streamlined approach to enhancing functionality. From the fundamental syntax to advanced implementations, we've navigated through their diverse applications. Whether you're fortifying security with custom modifiers, embracing efficiency with built-in tools, or delving into advanced scenarios, modifiers prove to be a versatile asset for developers. As you integrate these concepts into your projects, prioritize simplicity, clear naming, and logical organization for code that not only works but is also easily understood. Happy coding on your Solidity journey!

Feel free to reach out for any further assistance.

FAQs

Q 1. Why should I use modifiers in my Solidity smart contracts?

A. Modifiers play a crucial role in refining and enhancing the functionality of smart contracts. They enable developers to add extra conditions or tasks to functions without cluttering the entire code, thus improving security, simplifying code, and making it more reusable. Modifiers are particularly useful for access control, input validation, and optimizing gas usage, ensuring cleaner and more efficient smart contract development.

Q 2. Can I create my own custom modifiers, and how would I use them?

A. Absolutely, developers can create custom modifiers tailored to specific project requirements. For instance, if you're building a voting system, you might create a custom modifier to ensure only eligible voters can cast their votes. The process involves defining the modifier with a specific condition, such as eligibility, and then applying it to functions where this condition should be enforced. This promotes code reuse and enhances the readability of your Solidity code.

Q 3. How do modifiers prevent reentrancy attacks, and why are they important?

A. Reentrancy attacks can occur when a function is called repeatedly before it completes its execution, potentially leading to unintended consequences. Modifiers can act as a safeguard against reentrancy by setting a lock during function execution and ensuring it won't be called again until completion. This prevents external parties from exploiting vulnerable functions. Modifiers, in this context, serve as a crucial security measure in Solidity, protecting smart contracts from unexpected behaviors and ensuring the integrity of the blockchain ecosystem.