# Gas Saving Technique 15: Cache External Call

{% hint style="info" %}
[**Book an audit with Zokyo**](https://www.zokyo.io/)
{% endhint %}

#### Introduction

Optimizing gas consumption is paramount when developing smart contracts on blockchain networks, such as Ethereum. Caching results from external contract calls is a valuable technique for saving gas, especially when you need to use the retrieved data multiple times within a function. This tutorial guides you through the process and benefits of caching external call results to optimize gas usage.

#### Impact & Details

**Understanding Gas Consumption**

* **External Call Costs**: Every call to an external contract consumes a significant amount of gas. If you need to use the result of an external call multiple times, making the call each time is inefficient and costly.
* **Caching Benefits**: By caching the result of an external call in a local variable, you can reuse this data without incurring the cost of multiple external calls, thereby saving gas.

#### How to Implement Caching for Gas Savings

**Practical Example: Caching External Call Results**

Below is an example illustrating how to optimize gas consumption through caching:

Before Optimization:

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

interface IRewardStaking {
    function rewardToken() external view returns (address);
}

contract MyContract {
    address public extraPool;

    function someFunction() public {
        // ... some code ...
        address token1 = IRewardStaking(extraPool).rewardToken();
        // ... some code that doesn't modify token1 ...
        address token2 = IRewardStaking(extraPool).rewardToken();
        // ... more code ...
    }
}
```

After Optimization:

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

interface IRewardStaking {
    function rewardToken() external view returns (address);
}

contract MyContract {
    address public extraPool;

    function someFunction() public {
        // ... some code ...
        address token = IRewardStaking(extraPool).rewardToken();
        // ... some code that doesn't modify token ...
        address token1 = token;  // Reusing cached value
        // ... more code ...
    }
}
```

In the optimized version, the result of `IRewardStaking(extraPool).rewardToken()` is cached in a local variable and reused, eliminating the need for a second external call and saving gas.

#### Recommended Mitigation Steps

1. **Identify Multiple External Calls**: Review your smart contracts and locate any repeated external calls whose results can be cached.
2. **Cache and Reuse**: Implement caching by saving the result of the first call in a local variable and reusing it where needed.
3. **Test**: After implementation, test the contract to ensure that it maintains its functionality while consuming less gas due to caching.

#### Conclusion

Caching external call results is a straightforward yet powerful optimization technique for saving gas in smart contracts. This approach is especially beneficial when dealing with repeated external calls within a function. Remember to rigorously test the contract after implementation to ensure its integrity while enjoying the benefits of optimized gas consumption.