Code Destine

Introduction

When it comes to writing efficient smart contracts in Solidity, understanding data structures plays a crucial role. In this article, we will explore the concept of ordered lists in Solidity and how we can create them using a mapping data structure. We’ll dive into the benefits of using this approach, examine a real-world example of a decentralized protocol utilizing it, and conclude with a code snippet for implementing ordered lists in Solidity.

How to create an ordered list in Solidity ?

Creating an ordered list involves arranging data in a structured manner where each element is associated with a specific position or index. Traditionally, arrays are used to store ordered lists; however, they can pose significant gas inefficiencies when reordering items frequently.

The trade-off with arrays

When using arrays to manage ordered lists, rearranging elements (i.e., moving, removing, or adding) results in large gas fees. Every time an operation modifies the order, the entire array needs to be updated, leading to higher computational costs.

Mapping of nodes

To enhance efficiency, we can opt for a more innovative approach by implementing a mapping of nodes. Each node within the mapping contains a link to the previous and next value, forming a linked list. This technique reduces gas costs significantly, as reordering no longer requires updating the entire list.

Example:

Consider a decentralized protocol called XYZ that manages a ordered list of registered users to know which user came first and so on. To efficiently track user registration, XYZ employs the mapping approach, saving on gas costs while maintaining flexibility.

In XYZ protocol, the list of users is kept as a maps of nodes, where each node represents a unique user address and link to previous node and next node. When new users join, XYZ simply adds a new node and adjusts the links of its neighbour’s. Likewise, when a user leaves the platform, XYZ removes the corresponding node and updates the neighbouring links. This streamlined process minimizes computational overhead and ensures a smooth user experience.

Code Implementation:

Let’s take a look at the Solidity code snippet for creating an ordered list using the mapping of nodes approach:

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.19;

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

contract Test {
    struct Node {
        address prev;
        address next;
    }
 
    mapping(address => Node) private userList;
 
    address private first;
    address private last;
 
    function addUserToList(address user) external {
        Node memory node = Node(user, address(0), address(0));
        userList[user] = node;
        if (first == address(0)) {
            first = user;
            last = user;
        } else {
            userList[last].next = user;
            userList[user].prev = last;
            last = user;
        }
    }
 
    function removeUserFromList(address user) external {
        require(userList[user].prev != address(0) && userList[user].next != address(0), "Cannot remove the first node.");

        address previousUser = userList[user].prev;
        address nextUser = userList[user].next;

        userList[previousUser].next = nextUser;
        userList[nextUser].prev = previousUser;

        delete userList[user];
    }
}

That’s all for Creating Ordered List : Solidity Programming, If you liked it, please share your thoughts in a comments section and share it with others too.