Add Array.uniquifySorted to the Arrays library

This adds a uniquifySorted function to remove duplicates from sorted arrays. The function has O(n) time complexity and works with uint256, address, and bytes32 array types. This is particularly useful when mappings cannot be utilized, and provides an easy way to combine Array.sort() + Array.uniquifySorted().

Fixes OpenZeppelin#5520

Co-Authored-By: Srinivas Sivaratri <[email protected]>

Author: sivaratrisrinivas

contracts/mocks/ArraysMock.sol

@@ -56,6 +56,10 @@ contract Uint256ArraysMock {
     function length() external view returns (uint256) {
         return _array.length;
     }
+
+    function uniquifySorted(uint256[] memory array) external pure returns (uint256[] memory) {
+        return array.uniquifySorted();
+    }
 }
 
 contract AddressArraysMock {
@@ -90,6 +94,10 @@ contract AddressArraysMock {
     function length() external view returns (uint256) {
         return _array.length;
     }
+
+    function uniquifySorted(address[] memory array) external pure returns (address[] memory) {
+        return array.uniquifySorted();
+    }
 }
 
 contract Bytes32ArraysMock {
@@ -124,4 +132,8 @@ contract Bytes32ArraysMock {
     function length() external view returns (uint256) {
         return _array.length;
     }
+
+    function uniquifySorted(bytes32[] memory array) external pure returns (bytes32[] memory) {
+        return array.uniquifySorted();
+    }
 }

contracts/utils/Arrays.sol

@@ -479,4 +479,69 @@ library Arrays {
             sstore(array.slot, len)
         }
     }
+
+    /**
+     * @dev Removes duplicate values from a sorted array. This function does not check that the array is sorted,
+     * behavior is undefined if the array is not sorted. The resulting array will have no duplicates and will
+     * be shorter or the same length as the input array.
+     *
+     * This operation is performed in-place by moving elements and modifying the length of the array.
+     * Time complexity O(n).
+     *
+     * WARNING: This function is destructive. It will modify the array passed by reference.
+     */
+    function uniquifySorted(uint256[] memory array) internal pure returns (uint256[] memory) {
+        if (array.length <= 1) {
+            return array;
+        }
+
+        uint256 resultSize = 1;
+        for (uint256 i = 1; i < array.length; ++i) {
+            if (array[i] != array[i - 1]) {
+                if (i != resultSize) {
+                    array[resultSize] = array[i];
+                }
+                ++resultSize;
+            }
+        }
+
+        // Resize the array by creating a new one (can't modify length of memory arrays directly)
+        uint256[] memory result = new uint256[](resultSize);
+        for (uint256 i = 0; i < resultSize; ++i) {
+            result[i] = array[i];
+        }
+        return result;
+    }
+
+    /**
+     * @dev Removes duplicate values from a sorted address array. This function does not check that the array
+     * is sorted, behavior is undefined if the array is not sorted. The resulting array will have no duplicates
+     * and will be shorter or the same length as the input array.
+     *
+     * This operation is performed in-place by moving elements and modifying the length of the array.
+     * Time complexity O(n).
+     *
+     * WARNING: This function is destructive. It will modify the array passed by reference.
+     */
+    function uniquifySorted(address[] memory array) internal pure returns (address[] memory) {
+        uint256[] memory castedArray = _castToUint256Array(array);
+        uniquifySorted(castedArray);
+        return array;
+    }
+
+    /**
+     * @dev Removes duplicate values from a sorted bytes32 array. This function does not check that the array
+     * is sorted, behavior is undefined if the array is not sorted. The resulting array will have no duplicates
+     * and will be shorter or the same length as the input array.
+     *
+     * This operation is performed in-place by moving elements and modifying the length of the array.
+     * Time complexity O(n).
+     *
+     * WARNING: This function is destructive. It will modify the array passed by reference.
+     */
+    function uniquifySorted(bytes32[] memory array) internal pure returns (bytes32[] memory) {
+        uint256[] memory castedArray = _castToUint256Array(array);
+        uniquifySorted(castedArray);
+        return array;
+    }
 }