Blockchain Cryptocurrency Ethereum Smart Contracts Web3

Understanding Eternal Storage Pattern in Solidity

In the ever-evolving world of blockchain technology, smart contract upgrades are a necessity. But what happens to the valuable data stored within those contracts? The Eternal Storage pattern emerges as a hero, saving the day by ensuring your data persists through contract upgrades.

What is the Eternal Storage Pattern?

Imagine a smart contract like a complex machine. The logic, the part that performs actions, is constantly being improved. But the machine also has a storage unit where it keeps important data. The Eternal Storage pattern separates these two aspects. The logic resides in an upgradeable contract, while a separate, immutable contract – the Eternal Storage – holds all the data.

Why Use Eternal Storage?

The benefits are numerous:

  • Smooth Upgrades: Deploy a new logic contract with the upgraded functionality without affecting the data. This keeps your application running seamlessly.
  • Data Integrity: Since the Eternal Storage is immutable, there’s no risk of accidentally overwriting or corrupting your data during upgrades.
  • Reduced Complexity: The logic contract focuses solely on functionality, making it cleaner and easier to maintain.

How Does it Work?

The Eternal Storage pattern typically involves three actors:

  1. Proxy Contract: This acts as the main point of entry for users. It forwards all function calls to the actual logic contract.
  2. Logic Contract: This contains the core functionality of your smart contract. It interacts with the Eternal Storage to retrieve and update data.
  3. Eternal Storage Contract: This immutable contract holds all your data. It provides functions for the logic contract to add, retrieve, and modify data using key-value mappings.

Things to Consider

While Eternal Storage offers significant advantages, there are a few aspects to keep in mind:

  • Increased Complexity: Having multiple contracts adds complexity to the development and deployment process.
  • Limited Data Types: Currently, Eternal Storage typically supports only basic data types like integers and strings.

Eternal Storage in Action

The Eternal Storage pattern finds applications in various scenarios:

  • Decentralized Finance (DeFi): Upgradable lending protocols can leverage Eternal Storage to ensure user balances and loan details remain secure during upgrades.
  • Supply Chain Management: Track product information and ownership history across the supply chain with confidence, knowing the data persists through contract improvements.
  • Gaming: Maintain player data like character stats and in-game items while introducing new features and balancing updates.


pragma solidity ^0.8.0;

contract EternalStorage {
  // Mapping to store data using keccak256 hash of a key string
  mapping(bytes32 => bytes32) private data;

  // Function to set a value for a key
  function setUint(string memory key, uint value) public {
    data[keccak256(abi.encodePacked(key))] = bytes32(uint(value));

  // Function to get a value for a key
  function getUint(string memory key) public view returns (uint) {
    return uint(data[keccak256(abi.encodePacked(key))]);

  // Add more functions to store and retrieve other data types as needed


pragma solidity ^0.8.0;

import "./EternalStorage.sol";

contract LogicContract {
  EternalStorage private storage_;

  constructor(address storageAddress) {
    storage_ = EternalStorage(storageAddress);

  // Example function to store a user's balance
  function setBalance(uint userId, uint amount) public {
    storage_.setUint(keccak256(abi.encodePacked("balance", userId)), amount);

  // Example function to get a user's balance
  function getBalance(uint userId) public view returns (uint) {
    return storage_.getUint(keccak256(abi.encodePacked("balance", userId)));

  // Add more logic functions that interact with EternalStorage


  1. EternalStorage.sol:
    • This contract defines a mapping to store data with keys formed by hashing a string and the value.
    • Functions setUint and getUint demonstrate storing and retrieving unsigned integers (uint). You can add similar functions for other data types.
  2. LogicContract.sol:
    • This contract imports EternalStorage.sol.
    • It has a constructor that takes the address of the deployed EternalStorage contract.
    • Functions setBalance and getBalance interact with EternalStorage to manage user balances.

Note: This is a simplified example. In a real implementation, you’d likely have a Proxy contract that forwards user calls to the LogicContract.


The Eternal Storage pattern provides a powerful tool for managing data in upgradeable smart contracts. By understanding its benefits and limitations, you can leverage this pattern to build robust and future-proof blockchain applications.

Leave A Comment