Add a function for shrinking memory arrays

🧐 Motivation Solidity in-memory arrays can’t grow, because reallocation would be expensive and difficult to perform safely. But they can safely shrink.

Quite often a memory array needs to be passed around with a length variable to simulate a dynamic data structure. In some cases it’s only ever decreasing, e.g. when items are popped and consumed. This is both inefficient and dangerous, because Solidity only checks array.length when sanity-checking accessed indexes, it doesn’t know about the other variable.

📝 Details Add a function to library Arrays:

function shrinkArray(uint256[] memory array, uint newLength) internal pure returns (uint256[] memory) {
    require(newLength <= array.length, "Array: length after shrinking larger than before");
    /// @solidity memory-safe-assembly
    assembly {
        mstore(array, newLength)
    }
    return array;
}

Edit: I think that shrinkArray is too verbose, just shrink would be a better name, it’d be called by Array.shrink(myArray, len); or when using Array for uint256[], just by myArray.shrink(len).

[frangio]

I’m concerned about the interaction with Solidity optimizations. I think that as long as the assembly block isn’t marked “memory-safe” things should be fine, but there is some risk… See the recent compiler bug related to memory and assembly.

[Amxx]

You are bechmarking a lot of extra stuff

        uint256[] memory array = new uint256[](100);
        uint256 sum1;
        uint256 sum2;
        uint256 sum3;

        uint gas1 = gasleft();
        for(uint i = 0; i < array.length; i++) {
            sum1 += array[i];
        }
        gas1 -= gasleft();

        uint gas2 = gasleft();
        unchecked {
            uint length = array.length;
            for(uint i = 0; i < length; i++) {
                sum2 += array[i];
            }
        }
        gas2 -= gasleft();

        uint gas3 = gasleft();
        while(array.length > 0) {
            sum3 += popArray(array);
        }
        gas3 -= gasleft();

With my compiler settings I get:

• iteration: 24442
• iteration with unchecked + caching: 11950
• popping: 21431

---

The basic iteration mload the length for every loop (and so does the popping) … that cost a lot. The basic iteration does safe math on i++ and bound checks on array[i] … that also cost a lot. there two account for more than half of the total cost.