Sign in Subscribe
4 min read

Functions in Solidity

Introduction

Functions are a fundamental part of any programming language, and Solidity is no exception. In Solidity, functions are used to define the behavior of contracts. In this blog post, we'll explore the different types of functions in Solidity, how to define them, and how to call them.

Function Type Notation

ADD INFORMATION

function (<parameter types>) {internal|external} [pure|view|payable] [returns (<return types>)]

Function Types in Solidity

There are several types of functions in Solidity, including:

  1. public: These functions can be called from anywhere, both internally and externally.
  2. external: These functions can only be called externally, not within the contract itself.
  3. internal: These functions can only be called within the contract itself, or within contracts that inherit from it.
  4. private: These functions can only be called from within the contract itself.

Defining Functions in Solidity

To define a function in Solidity, you use the function keyword, followed by the name of the function, and then the list of parameters within parentheses. Here's an example:

function add(uint256 a, uint256 b) public returns (uint256) {
  return a + b;
}

In this example, we define a public function called add that takes two unsigned integer parameters, a and b. The function returns the sum of a and b.

Function Modifiers in Solidity

In addition to the function types, Solidity also supports function modifiers. A function modifier is a special keyword that can be used to change the behavior of a function. Modifiers are often used to add extra security checks or to modify the input or output of a function.

Here's an example of a function with a modifier:

modifier onlyOwner {
  require(msg.sender == owner);
  _;
}

function changeOwner(address newOwner) public onlyOwner {
  owner = newOwner;
}

In this example, we define a modifier called onlyOwner that requires the caller of the function to be the owner of the contract. The changeOwner function uses the onlyOwner modifier to ensure that only the owner of the contract can change the owner address.

Calling Functions in Solidity

To call a function in Solidity, you use the name of the function, followed by the list of parameters within parentheses. Here's an example:

uint256 result = myContract.add(2, 3);

In this example, we call the add function on a contract called myContract, passing in the values 2 and 3. The function returns the sum of the two values, which we store in a variable called result.

Function Overloading in Solidity

Solidity supports function overloading, which means you can define multiple functions with the same name but different parameters. Here's an example:

function add(uint256 a, uint256 b) public returns (uint256) {
  return a + b;
}

function add(string memory a, string memory b) public returns (string memory) {
  return string(abi.encodePacked(a, b));
}

In this example, we define two functions called add. The first function takes two unsigned integer parameters and returns their sum. The second function takes two string parameters and returns their concatenation.

Function Examples with SimpleStorage

Here's an example implementation of the SimpleStorage contract which includes the concepts covered above.

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

// Define a SimpleStorage contract
contract SimpleStorage {
    // Define variable to store a uint256 value
    uint256 public storedData;

    // Define a function to set the storedData variable
    function set(uint256 x) public {
        storedData = x;
    }
    
    // Define a function to get the storedData variable
    function get() public view returns (uint256) {
        return storedData;
    }
    
    // Define an overloaded set function with a string input parameter
    function set(string memory str) public {
        // Convert the string to a bytes32 variable
        bytes32 val = keccak256(abi.encodePacked(str));
        // Set the storedData variable to the hashed value
        storedData = uint256(val);
    }
    
    // Define a function modifier to allow only the contract owner to call a function
    modifier onlyOwner() {
        require(msg.sender == owner, "Only the contract owner can call this function");
        _;
    }

    // Define a variable to store the contract owner's address
    address owner;

    // Define a constructor function to set the owner variable
    constructor() {
        owner = msg.sender;
    }

    // Define a function that can only be called by the contract owner
    function changeOwner(address newOwner) public onlyOwner {
        owner = newOwner;
    }
}

// Define a new contract that calls the SimpleStorage contract method
contract CallsSimpleStorage {
    // Create an instance of the SimpleStorage contract
    SimpleStorage simpleStorage = new SimpleStorage();

    // Define a function to get the storedData value from the SimpleStorage contract
    function getStoredData() public view returns (uint256) {
        return simpleStorage.get();
    }

    // Define a function to set the storedData value in the SimpleStorage contract
    function setStoredData(uint256 x) public {
        simpleStorage.set(x);
    }
}

In this example, we define a SimpleStorage contract that includes a set function to set the value of the storedData variable, a get function to retrieve the value of storedData, and an overloaded set function that accepts a string input parameter and hashes it to set the value of storedData.

We also define a function modifier onlyOwner that restricts certain functions to be called only by the contract owner. The changeOwner function is an example of a function that can only be called by the contract owner.

Lastly, we define a separate CallsSimpleStorage contract that creates an instance of the SimpleStorage contract and includes functions to get and set the storedData value in the SimpleStorage contract.

Conclusion

Functions are an essential part of Solidity programming. In this blog post, we've explored the different types of functions in Solidity, how to define them, and how to call them. We've also looked at function modifiers and function overloading. With this knowledge, you should be able to start writing your own Solidity functions and building more complex smart contracts.

Feedback

Have feedback? Found something that needs to be updated, accurate, or explained?

Join our discord and share what can be improved.

Any and all feedback is welcomed.

Published by:

Anthony Albertorio