Add RLP library

.changeset/lovely-cooks-add.md

@@ -0,0 +1,5 @@
+---
+'openzeppelin-solidity': minor
+---
+
+`RLP`: Add library for Ethereum's Recursive Length Prefix encoding/decoding.

contracts/mocks/Stateless.sol

@@ -44,6 +44,7 @@ import {P256} from "../utils/cryptography/P256.sol";
 import {Packing} from "../utils/Packing.sol";
 import {Panic} from "../utils/Panic.sol";
 import {RelayedCall} from "../utils/RelayedCall.sol";
+import {RLP} from "../utils/RLP.sol";
 import {RSA} from "../utils/cryptography/RSA.sol";
 import {SafeCast} from "../utils/math/SafeCast.sol";
 import {SafeERC20} from "../token/ERC20/utils/SafeERC20.sol";

contracts/token/ERC20/extensions/ERC4626.sol

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

contracts/utils/Bytes.sol

@@ -4,6 +4,7 @@
 pragma solidity ^0.8.24;
 
 import {Math} from "./math/Math.sol";
+import {Memory} from "./Memory.sol";
 
 /**
  * @dev Bytes operations.
@@ -244,4 +245,87 @@ library Bytes {
             value := mload(add(add(buffer, 0x20), offset))
         }
     }
+
+    /**
+     * @dev Bytes accumulator: a linked list of `bytes`.
+     *
+     * Note: This is a memory structure that SHOULD not be put in storage.
+     */
+    struct Accumulator {
+        Memory.Pointer head;
+        Memory.Pointer tail;
+    }
+
+    /// @dev Item (list node) in a bytes accumulator
+    struct AccumulatorEntry {
+        Memory.Pointer next;
+        bytes data;
+    }
+
+    /// @dev Create a new (empty) accumulator
+    function accumulator() internal pure returns (Accumulator memory self) {
+        self.head = Memory.asPointer(0x00);
+        self.tail = Memory.asPointer(0x00);
+    }
+
+    /// @dev Add a bytes buffer to (the end of) an Accumulator
+    function push(Accumulator memory self, bytes memory data) internal pure returns (Accumulator memory) {
+        Memory.Pointer ptr = _asPtr(AccumulatorEntry({next: Memory.asPointer(0x00), data: data}));
+
+        if (Memory.asBytes32(self.head) == 0x00) {
+            self.head = ptr;
+            self.tail = ptr;
+        } else {
+            _asAccumulatorEntry(self.tail).next = ptr;
+            self.tail = ptr;
+        }
+
+        return self;
+    }
+
+    /// @dev Add a bytes buffer to (the beginning of) an Accumulator
+    function shift(Accumulator memory self, bytes memory data) internal pure returns (Accumulator memory) {
+        Memory.Pointer ptr = _asPtr(AccumulatorEntry({next: self.head, data: data}));
+
+        if (Memory.asBytes32(self.head) == 0x00) {
+            self.head = ptr;
+            self.tail = ptr;
+        } else {
+            self.head = ptr;
+        }
+
+        return self;
+    }
+
+    /// @dev Flatten all the bytes entries in an Accumulator into a single buffer
+    function flatten(Accumulator memory self) internal pure returns (bytes memory result) {
+        assembly ("memory-safe") {
+            result := mload(0x40)
+            let ptr := add(result, 0x20)
+            for {
+                let it := mload(self)
+            } iszero(iszero(it)) {
+                it := mload(it)
+            } {
+                let buffer := mload(add(it, 0x20))
+                let length := mload(buffer)
+                mcopy(ptr, add(buffer, 0x20), length)
+                ptr := add(ptr, length)
+            }
+            mstore(result, sub(ptr, add(result, 0x20)))
+            mstore(0x40, ptr)
+        }
+    }
+
+    function _asPtr(AccumulatorEntry memory item) private pure returns (Memory.Pointer ptr) {
+        assembly ("memory-safe") {
+            ptr := item
+        }
+    }
+
+    function _asAccumulatorEntry(Memory.Pointer ptr) private pure returns (AccumulatorEntry memory item) {
+        assembly ("memory-safe") {
+            item := ptr
+        }
+    }
 }

contracts/utils/Memory.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.24;
+
+import {Panic} from "./Panic.sol";
 
 /**
  * @dev Utilities to manipulate memory.
@@ -41,4 +43,71 @@ library Memory {
     function asPointer(bytes32 value) internal pure returns (Pointer) {
         return Pointer.wrap(value);
     }
+
+    type Slice is bytes32;
+
+    /// @dev Get a slice representation of a bytes object in memory
+    function asSlice(bytes memory self) internal pure returns (Slice result) {
+        assembly ("memory-safe") {
+            result := or(shl(128, mload(self)), add(self, 0x20))
+        }
+    }
+
+    /// @dev Private helper: create a slice from raw values (length and pointer)
+    function _asSlice(uint256 len, Memory.Pointer ptr) private pure returns (Slice result) {
+        // TODO: Fail if len or ptr  is larger than type(uint128).max ?
+        assembly ("memory-safe") {
+            result := or(shl(128, len), ptr)
+        }
+    }
+
+    /// @dev Returns the memory location of a given slice (equiv to self.offset for calldata slices)
+    function _pointer(Slice self) private pure returns (Memory.Pointer result) {
+        assembly ("memory-safe") {
+            result := and(self, shr(128, not(0)))
+        }
+    }
+
+    /// @dev Returns the length of a given slice (equiv to self.length for calldata slices)
+    function length(Slice self) internal pure returns (uint256 result) {
+        assembly ("memory-safe") {
+            result := shr(128, self)
+        }
+    }
+
+    /// @dev Offset a memory slice (equivalent to self[start:] for calldata slices)
+    function slice(Slice self, uint256 offset) internal pure returns (Slice) {
+        if (offset > length(self)) Panic.panic(Panic.ARRAY_OUT_OF_BOUNDS);
+        return _asSlice(length(self) - offset, asPointer(bytes32(uint256(asBytes32(_pointer(self))) + offset)));
+    }
+
+    /// @dev Offset and cut a Slice (equivalent to self[start:start+length] for calldata slices)
+    function slice(Slice self, uint256 offset, uint256 len) internal pure returns (Slice) {
+        if (offset + len > length(self)) Panic.panic(Panic.ARRAY_OUT_OF_BOUNDS);
+        return _asSlice(len, asPointer(bytes32(uint256(asBytes32(_pointer(self))) + offset)));
+    }
+
+    /**
+     * @dev Read a bytes32 buffer from a given Slice at a specific offset
+     *
+     * Note:If offset > length(slice) - 32, part of the return value will be out of bound and should be ignored.
+     */
+    function load(Slice self, uint256 offset) internal pure returns (bytes32 value) {
+        if (offset >= length(self)) Panic.panic(Panic.ARRAY_OUT_OF_BOUNDS);
+        assembly ("memory-safe") {
+            value := mload(add(and(self, shr(128, not(0))), offset))
+        }
+    }
+
+    /// @dev Extract the data corresponding to a Slice (allocate new memory)
+    function toBytes(Slice self) internal pure returns (bytes memory result) {
+        uint256 len = length(self);
+        Memory.Pointer ptr = _pointer(self);
+        assembly ("memory-safe") {
+            result := mload(0x40)
+            mstore(result, len)
+            mcopy(add(result, 0x20), ptr, len)
+            mstore(0x40, add(add(result, len), 0x20))
+        }
+    }
 }

contracts/utils/README.adoc

@@ -38,6 +38,7 @@ Miscellaneous contracts and libraries containing utility functions you can use t
  * {Packing}: A library for packing and unpacking multiple values into bytes32.
  * {Panic}: A library to revert with https://docs.soliditylang.org/en/v0.8.20/control-structures.html#panic-via-assert-and-error-via-require[Solidity panic codes].
  * {RelayedCall}: A library for performing calls that use minimal and predictable relayers to hide the sender.
+ * {RLP}: Library for encoding and decoding data in Ethereum's Recursive Length Prefix format.
  * {ShortStrings}: Library to encode (and decode) short strings into (or from) a single bytes32 slot for optimizing costs. Short strings are limited to 31 characters.
  * {SlotDerivation}: Methods for deriving storage slot from ERC-7201 namespaces as well as from constructions such as mapping and arrays.
  * {StorageSlot}: Methods for accessing specific storage slots formatted as common primitive types.
@@ -138,6 +139,8 @@ Ethereum contracts have no native concept of an interface, so applications must
 
 {{RelayedCall}}
 
+{{RLP}}
+
 {{ShortStrings}}
 
 {{SlotDerivation}}