Add Array.slice and Array.splice for value type arrays (#5965)

Co-authored-by: Hadrien Croubois <[email protected]>

Author: ernestognw

.changeset/swift-planets-juggle.md

@@ -0,0 +1,5 @@
+---
+'openzeppelin-solidity': minor
+---
+
+`Arrays`: Add `slice` and `splice` functions for value types (`uint256[]`, `bytes32[]`, `address[]`).

CHANGELOG.md

@@ -10,7 +10,7 @@
 - `ERC6909` and the its extensions (`ERC6909ContentURI`, `ERC6909Metadata` and `ERC6909TokenSupply`) are no longer marked as draft since [EIP-6909](https://eips.ethereum.org/EIPS/eip-6909) is now final. Developers must update the import paths. Contracts behavior is not modified.
 - `SignerERC7702` is renamed as `SignerEIP7702`. Imports and inheritance must be updated to that new name and path. Behavior is unmodified.
 - `ERC721Holder`, `ERC1155Holder`, `ReentrancyGuard` and `ReentrancyGuardTransient` are flagged as stateless and are no longer transpiled. Developers using their upgradeable variants from `@openzeppelin/contracts-upgradeable` must update their imports to use the equivalent version available in `@openzeppelin/contracts`.
-- Update minimum pragma to 0.8.24 in `Votes`, `VotesExtended`, `ERC20Votes`, `Strings`, `ERC1155URIStorage`, `MessageHashUtils`, `ERC721URIStorage`, `ERC721Votes`, `ERC721Wrapper`, `ERC721Burnable`, `ERC721Consecutive`, `ERC721Enumerable`, `ERC721Pausable`, `ERC721Royalty`, `ERC721Wrapper`, `EIP712`, `ERC4626` and `ERC7739`. ([#5726](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5726))
+- Update minimum pragma to 0.8.24 in `AccessControlEnumerable`, `Arrays`, `CircularBuffer`, `EIP712`, `EnumerableMap`, `EnumerableSet`, `ERC1155`, `ERC1155Burnable`, `ERC1155Pausable`, `ERC1155Supply`, `ERC1155URIStorage`, `ERC20Votes`, `ERC4626`,`ERC721Burnable`, `ERC721Consecutive`, `ERC721Enumerable`, `ERC721Pausable`, `ERC721Royalty`, `ERC721URIStorage`, `ERC721Votes`, `ERC721Wrapper`, `ERC7739`, `Heap`, `MerkleTree`, `MessageHashUtils`, `Strings`, `Votes` and `VotesExtended`. ([#5723](https://github.com/OpenZeppelin/openzeppelin-contracts/issues/5723), [#5726](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5726), [#5965](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5965))
 - `Account`: Add `signature` argument to the internal `_validateUserOp` function for custom signature handling logic. Developers overriding it must now provide the signature from the user operation (i.e. `userOp.signature`) to keep compatibility. ([#5976](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5976))
 - `AccountERC7579`: Installing and uninstalling fallback modules now require the corresponding `initData` and `deInitData` arguments to be at least 4 bytes long (matching the selector to which the fallback module is registered). It now reverts with `ERC7579CannotDecodeFallbackData` instead of treating the missing bytes as `0x00`. ([#5974](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5974))
 

contracts/access/extensions/AccessControlEnumerable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 // OpenZeppelin Contracts (last updated v5.4.0) (access/extensions/AccessControlEnumerable.sol)
 
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.24;
 
 import {IAccessControlEnumerable} from "./IAccessControlEnumerable.sol";
 import {AccessControl} from "../AccessControl.sol";

contracts/token/ERC1155/ERC1155.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC1155/ERC1155.sol)
 
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.24;
 
 import {IERC1155} from "./IERC1155.sol";
 import {IERC1155MetadataURI} from "./extensions/IERC1155MetadataURI.sol";

contracts/token/ERC1155/extensions/ERC1155Burnable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/ERC1155Burnable.sol)
 
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.24;
 
 import {ERC1155} from "../ERC1155.sol";
 

contracts/token/ERC1155/extensions/ERC1155Pausable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/extensions/ERC1155Pausable.sol)
 
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.24;
 
 import {ERC1155} from "../ERC1155.sol";
 import {Pausable} from "../../../utils/Pausable.sol";

contracts/token/ERC1155/extensions/ERC1155Supply.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC1155/extensions/ERC1155Supply.sol)
 
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.24;
 
 import {ERC1155} from "../ERC1155.sol";
 import {Arrays} from "../../../utils/Arrays.sol";

contracts/utils/Arrays.sol

@@ -2,7 +2,7 @@
 // OpenZeppelin Contracts (last updated v5.4.0) (utils/Arrays.sol)
 // This file was procedurally generated from scripts/generate/templates/Arrays.js.
 
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.24;
 
 import {Comparators} from "./Comparators.sol";
 import {SlotDerivation} from "./SlotDerivation.sol";
@@ -375,6 +375,189 @@ library Arrays {
         return low;
     }
 
+    /**
+     * @dev Copies the content of `array`, from `start` (included) to the end of `array` into a new address array in
+     * memory.
+     *
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]
+     */
+    function slice(address[] memory array, uint256 start) internal pure returns (address[] memory) {
+        return slice(array, start, array.length);
+    }
+
+    /**
+     * @dev Copies the content of `array`, from `start` (included) to `end` (excluded) into a new address array in
+     * memory. The `end` argument is truncated to the length of the `array`.
+     *
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]
+     */
+    function slice(address[] memory array, uint256 start, uint256 end) internal pure returns (address[] memory) {
+        // sanitize
+        end = Math.min(end, array.length);
+        start = Math.min(start, end);
+
+        // allocate and copy
+        address[] memory result = new address[](end - start);
+        assembly ("memory-safe") {
+            mcopy(add(result, 0x20), add(add(array, 0x20), mul(start, 0x20)), mul(sub(end, start), 0x20))
+        }
+
+        return result;
+    }
+
+    /**
+     * @dev Copies the content of `array`, from `start` (included) to the end of `array` into a new bytes32 array in
+     * memory.
+     *
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]
+     */
+    function slice(bytes32[] memory array, uint256 start) internal pure returns (bytes32[] memory) {
+        return slice(array, start, array.length);
+    }
+
+    /**
+     * @dev Copies the content of `array`, from `start` (included) to `end` (excluded) into a new bytes32 array in
+     * memory. The `end` argument is truncated to the length of the `array`.
+     *
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]
+     */
+    function slice(bytes32[] memory array, uint256 start, uint256 end) internal pure returns (bytes32[] memory) {
+        // sanitize
+        end = Math.min(end, array.length);
+        start = Math.min(start, end);
+
+        // allocate and copy
+        bytes32[] memory result = new bytes32[](end - start);
+        assembly ("memory-safe") {
+            mcopy(add(result, 0x20), add(add(array, 0x20), mul(start, 0x20)), mul(sub(end, start), 0x20))
+        }
+
+        return result;
+    }
+
+    /**
+     * @dev Copies the content of `array`, from `start` (included) to the end of `array` into a new uint256 array in
+     * memory.
+     *
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]
+     */
+    function slice(uint256[] memory array, uint256 start) internal pure returns (uint256[] memory) {
+        return slice(array, start, array.length);
+    }
+
+    /**
+     * @dev Copies the content of `array`, from `start` (included) to `end` (excluded) into a new uint256 array in
+     * memory. The `end` argument is truncated to the length of the `array`.
+     *
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]
+     */
+    function slice(uint256[] memory array, uint256 start, uint256 end) internal pure returns (uint256[] memory) {
+        // sanitize
+        end = Math.min(end, array.length);
+        start = Math.min(start, end);
+
+        // allocate and copy
+        uint256[] memory result = new uint256[](end - start);
+        assembly ("memory-safe") {
+            mcopy(add(result, 0x20), add(add(array, 0x20), mul(start, 0x20)), mul(sub(end, start), 0x20))
+        }
+
+        return result;
+    }
+
+    /**
+     * @dev Moves the content of `array`, from `start` (included) to the end of `array` to the start of that array.
+     *
+     * NOTE: This function modifies the provided array in place. If you need to preserve the original array, use {slice} instead.
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]
+     */
+    function splice(address[] memory array, uint256 start) internal pure returns (address[] memory) {
+        return splice(array, start, array.length);
+    }
+
+    /**
+     * @dev Moves the content of `array`, from `start` (included) to `end` (excluded) to the start of that array. The
+     * `end` argument is truncated to the length of the `array`.
+     *
+     * NOTE: This function modifies the provided array in place. If you need to preserve the original array, use {slice} instead.
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]
+     */
+    function splice(address[] memory array, uint256 start, uint256 end) internal pure returns (address[] memory) {
+        // sanitize
+        end = Math.min(end, array.length);
+        start = Math.min(start, end);
+
+        // move and resize
+        assembly ("memory-safe") {
+            mcopy(add(array, 0x20), add(add(array, 0x20), mul(start, 0x20)), mul(sub(end, start), 0x20))
+            mstore(array, sub(end, start))
+        }
+
+        return array;
+    }
+
+    /**
+     * @dev Moves the content of `array`, from `start` (included) to the end of `array` to the start of that array.
+     *
+     * NOTE: This function modifies the provided array in place. If you need to preserve the original array, use {slice} instead.
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]
+     */
+    function splice(bytes32[] memory array, uint256 start) internal pure returns (bytes32[] memory) {
+        return splice(array, start, array.length);
+    }
+
+    /**
+     * @dev Moves the content of `array`, from `start` (included) to `end` (excluded) to the start of that array. The
+     * `end` argument is truncated to the length of the `array`.
+     *
+     * NOTE: This function modifies the provided array in place. If you need to preserve the original array, use {slice} instead.
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]
+     */
+    function splice(bytes32[] memory array, uint256 start, uint256 end) internal pure returns (bytes32[] memory) {
+        // sanitize
+        end = Math.min(end, array.length);
+        start = Math.min(start, end);
+
+        // move and resize
+        assembly ("memory-safe") {
+            mcopy(add(array, 0x20), add(add(array, 0x20), mul(start, 0x20)), mul(sub(end, start), 0x20))
+            mstore(array, sub(end, start))
+        }
+
+        return array;
+    }
+
+    /**
+     * @dev Moves the content of `array`, from `start` (included) to the end of `array` to the start of that array.
+     *
+     * NOTE: This function modifies the provided array in place. If you need to preserve the original array, use {slice} instead.
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]
+     */
+    function splice(uint256[] memory array, uint256 start) internal pure returns (uint256[] memory) {
+        return splice(array, start, array.length);
+    }
+
+    /**
+     * @dev Moves the content of `array`, from `start` (included) to `end` (excluded) to the start of that array. The
+     * `end` argument is truncated to the length of the `array`.
+     *
+     * NOTE: This function modifies the provided array in place. If you need to preserve the original array, use {slice} instead.
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]
+     */
+    function splice(uint256[] memory array, uint256 start, uint256 end) internal pure returns (uint256[] memory) {
+        // sanitize
+        end = Math.min(end, array.length);
+        start = Math.min(start, end);
+
+        // move and resize
+        assembly ("memory-safe") {
+            mcopy(add(array, 0x20), add(add(array, 0x20), mul(start, 0x20)), mul(sub(end, start), 0x20))
+            mstore(array, sub(end, start))
+        }
+
+        return array;
+    }
+
     /**
      * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
      *

contracts/utils/Bytes.sol

@@ -85,8 +85,7 @@ library Bytes {
      */
     function slice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {
         // sanitize
-        uint256 length = buffer.length;
-        end = Math.min(end, length);
+        end = Math.min(end, buffer.length);
         start = Math.min(start, end);
 
         // allocate and copy
@@ -102,6 +101,7 @@ library Bytes {
      * @dev Moves the content of `buffer`, from `start` (included) to the end of `buffer` to the start of that buffer.
      *
      * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]
      */
     function splice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {
         return splice(buffer, start, buffer.length);
@@ -112,11 +112,11 @@ library Bytes {
      * `end` argument is truncated to the length of the `buffer`.
      *
      * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead
+     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]
      */
     function splice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {
         // sanitize
-        uint256 length = buffer.length;
-        end = Math.min(end, length);
+        end = Math.min(end, buffer.length);
         start = Math.min(start, end);
 
         // allocate and copy

contracts/utils/structs/CircularBuffer.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 // OpenZeppelin Contracts (last updated v5.3.0) (utils/structs/CircularBuffer.sol)
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.24;
 
 import {Math} from "../math/Math.sol";
 import {Arrays} from "../Arrays.sol";