Last Updated on 25. November 2025 by Mario Oettler

The EVM (Ethereum Virtual Machine) distinguishes between different locations where to store data. One location is the storage. It is written to the blockchain and therefore persistent. The problem however is that it is very expensive and increases the size of the blockchain as every value is written to and read from the disk.

But sometimes it is not necessary to store a value permanently on the blockchain but make it only persistent during one transaction but in multiple call frames.

When using calls, contracts have two ways to exchange data:

1. Use input/output (parameters): But when calling external contracts, one cannot rely on the values returned. The variable bool locked is stored as memory and thus only available within the function.

Access data stored in the storage (permanently). But as we know, storage is expensive and thus, many developers refrain from using it if possible. 

This is where transient storage enters the stage.

Transient storage uses an empty storage slot, writes data to it and once the transaction is finished, this slot is cleared. The data stored in this slot is available in all functions and smart contracts called during this transaction. This allows data to be shared securely without the risk of manipulation.

Example

In this example, the value in the transient storage variable tval is shared among different contracts. Compared to storing it in the storage variable sval the transient storage approach is much cheaper.

pragma solidity 0.8.30;

contract SC01{
    uint public transient tval;
    uint public sval;

    function startTransientStorage(address sc02_addr) public returns(uint256){
        // setting transient storage
        tval = 200;
        uint256 val;

        // calling SC02 to fetch transient storage
        SC02 a = SC02(sc02_addr);
        val = a.readTransientStorage(address(this));
        return val;
    }

    function startStorage(address sc02_addr) public returns(uint256){
        // setting storage
        sval = 200;
        uint256 val;

        // calling SC02 to fetch storage
        SC02 a = SC02(sc02_addr);
        val = a.readStorage(address(this));
        return val;
    }
}


contract SC02{
    bytes32 constant SLOT = 0;
    function readTransientStorage(address sc01_addr) public view returns(uint256 v){
        uint256 val;
        SC01 a = SC01(sc01_addr);
        val = a.tval();
        return val;
    }

    function readStorage(address sc01_addr) public view returns(uint256 v){
        uint256 val;
        SC01 a = SC01(sc01_addr);
        val = a.sval();
        return val;
    }
}