Implement LowLevelCall library

.changeset/dull-students-eat.md

@@ -0,0 +1,5 @@
+---
+'openzeppelin-solidity': minor
+---
+
+`Memory`: Add library with utilities to manipulate memory

.changeset/sharp-scissors-drum.md

@@ -0,0 +1,5 @@
+---
+'openzeppelin-solidity': minor
+---
+
+`LowLevelCall`: Add a library to perform low-level calls and deal with the `returndata` more granularly.

contracts/account/Account.sol

@@ -5,6 +5,7 @@ pragma solidity ^0.8.20;
 import {PackedUserOperation, IAccount, IEntryPoint} from "../interfaces/draft-IERC4337.sol";
 import {ERC4337Utils} from "./utils/draft-ERC4337Utils.sol";
 import {AbstractSigner} from "../utils/cryptography/signers/AbstractSigner.sol";
+import {LowLevelCall} from "../utils/LowLevelCall.sol";
 
 /**
  * @dev A simple ERC4337 account implementation. This base implementation only includes the minimal logic to process
@@ -112,8 +113,7 @@ abstract contract Account is AbstractSigner, IAccount {
      */
     function _payPrefund(uint256 missingAccountFunds) internal virtual {
         if (missingAccountFunds > 0) {
-            (bool success, ) = payable(msg.sender).call{value: missingAccountFunds}("");
-            success; // Silence warning. The entrypoint should validate the result.
+            LowLevelCall.callRaw(msg.sender, "", missingAccountFunds); // The entrypoint should validate the result.
         }
     }
 

contracts/account/extensions/AccountERC7579.sol

@@ -7,6 +7,8 @@ import {IERC1271} from "../../interfaces/IERC1271.sol";
 import {IERC7579Module, IERC7579Validator, IERC7579Execution, IERC7579AccountConfig, IERC7579ModuleConfig, MODULE_TYPE_VALIDATOR, MODULE_TYPE_EXECUTOR, MODULE_TYPE_FALLBACK} from "../../interfaces/draft-IERC7579.sol";
 import {ERC7579Utils, Mode, CallType, ExecType} from "../../account/utils/draft-ERC7579Utils.sol";
 import {EnumerableSet} from "../../utils/structs/EnumerableSet.sol";
+import {LowLevelCall} from "../../utils/LowLevelCall.sol";
+import {Memory} from "../../utils/Memory.sol";
 import {Bytes} from "../../utils/Bytes.sol";
 import {Packing} from "../../utils/Packing.sol";
 import {Address} from "../../utils/Address.sol";
@@ -50,6 +52,8 @@ abstract contract AccountERC7579 is Account, IERC1271, IERC7579Execution, IERC75
     using ERC7579Utils for *;
     using EnumerableSet for *;
     using Packing for bytes32;
+    using LowLevelCall for *;
+    using Memory for *;
 
     EnumerableSet.AddressSet private _validators;
     EnumerableSet.AddressSet private _executors;
@@ -311,9 +315,7 @@ abstract contract AccountERC7579 is Account, IERC1271, IERC7579Execution, IERC75
 
         if (success) return returndata;
 
-        assembly ("memory-safe") {
-            revert(add(returndata, 0x20), mload(returndata))
-        }
+        returndata.asPointer().addOffset(0x20).asBytes().bubbleRevert();
     }
 
     /// @dev Returns the fallback handler for the given selector. Returns `address(0)` if not installed.

contracts/mocks/CallReceiverMock.sol

@@ -25,6 +25,12 @@ contract CallReceiverMock {
         return "0x1234";
     }
 
+    function mockFunctionWithArgsReturn(uint256 a, uint256 b) public payable returns (uint256, uint256) {
+        emit MockFunctionCalledWithArgs(a, b);
+
+        return (a, b);
+    }
+
     function mockFunctionNonPayable() public returns (string memory) {
         emit MockFunctionCalled();
 
@@ -35,6 +41,10 @@ contract CallReceiverMock {
         return "0x1234";
     }
 
+    function mockStaticFunctionWithArgsReturn(uint256 a, uint256 b) public pure returns (uint256, uint256) {
+        return (a, b);
+    }
+
     function mockFunctionRevertsNoReason() public payable {
         revert();
     }

contracts/mocks/Stateless.sol

@@ -25,12 +25,14 @@ import {EnumerableSet} from "../utils/structs/EnumerableSet.sol";
 import {ERC165} from "../utils/introspection/ERC165.sol";
 import {ERC165Checker} from "../utils/introspection/ERC165Checker.sol";
 import {ERC721Holder} from "../token/ERC721/utils/ERC721Holder.sol";
+import {LowLevelCall} from "../utils/LowLevelCall.sol";
 import {ERC1155Holder} from "../token/ERC1155/utils/ERC1155Holder.sol";
 import {ERC1967Utils} from "../proxy/ERC1967/ERC1967Utils.sol";
 import {ERC4337Utils} from "../account/utils/draft-ERC4337Utils.sol";
 import {ERC7579Utils} from "../account/utils/draft-ERC7579Utils.sol";
 import {Heap} from "../utils/structs/Heap.sol";
 import {Math} from "../utils/math/Math.sol";
+import {Memory} from "../utils/Memory.sol";
 import {MerkleProof} from "../utils/cryptography/MerkleProof.sol";
 import {MessageHashUtils} from "../utils/cryptography/MessageHashUtils.sol";
 import {Nonces} from "../utils/Nonces.sol";

contracts/proxy/transparent/ProxyAdmin.sol

@@ -5,6 +5,7 @@ pragma solidity ^0.8.22;
 
 import {ITransparentUpgradeableProxy} from "./TransparentUpgradeableProxy.sol";
 import {Ownable} from "../../access/Ownable.sol";
+import {LowLevelCall} from "../../utils/LowLevelCall.sol";
 
 /**
  * @dev This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an
@@ -40,6 +41,10 @@ contract ProxyAdmin is Ownable {
         address implementation,
         bytes memory data
     ) public payable virtual onlyOwner {
-        proxy.upgradeToAndCall{value: msg.value}(implementation, data);
+        LowLevelCall.callRaw(
+            address(proxy),
+            abi.encodeCall(ITransparentUpgradeableProxy.upgradeToAndCall, (implementation, data)),
+            msg.value
+        );
     }
 }

contracts/token/ERC20/extensions/ERC4626.sol

@@ -6,6 +6,7 @@ pragma solidity ^0.8.20;
 import {IERC20, IERC20Metadata, ERC20} from "../ERC20.sol";
 import {SafeERC20} from "../utils/SafeERC20.sol";
 import {IERC4626} from "../../../interfaces/IERC4626.sol";
+import {LowLevelCall} from "../../../utils/LowLevelCall.sol";
 import {Math} from "../../../utils/math/Math.sol";
 
 /**
@@ -84,11 +85,12 @@ abstract contract ERC4626 is ERC20, IERC4626 {
      * @dev Attempts to fetch the asset decimals. A return value of false indicates that the attempt failed in some way.
      */
     function _tryGetAssetDecimals(IERC20 asset_) private view returns (bool ok, uint8 assetDecimals) {
-        (bool success, bytes memory encodedDecimals) = address(asset_).staticcall(
+        (bool success, bytes32 encodedDecimals) = LowLevelCall.staticcallReturnBytes32(
+            address(asset_),
             abi.encodeCall(IERC20Metadata.decimals, ())
         );
-        if (success && encodedDecimals.length >= 32) {
-            uint256 returnedDecimals = abi.decode(encodedDecimals, (uint256));
+        if (success && LowLevelCall.returnDataSize() >= 32) {
+            uint256 returnedDecimals = uint256(encodedDecimals);
             if (returnedDecimals <= type(uint8).max) {
                 return (true, uint8(returnedDecimals));
             }

contracts/token/ERC20/utils/SafeERC20.sol

@@ -5,6 +5,9 @@ pragma solidity ^0.8.20;
 
 import {IERC20} from "../IERC20.sol";
 import {IERC1363} from "../../../interfaces/IERC1363.sol";
+import {Address} from "../../../utils/Address.sol";
+import {LowLevelCall} from "../../../utils/LowLevelCall.sol";
+import {Memory} from "../../../utils/Memory.sol";
 
 /**
  * @title SafeERC20
@@ -31,15 +34,19 @@ library SafeERC20 {
      * non-reverting calls are assumed to be successful.
      */
     function safeTransfer(IERC20 token, address to, uint256 value) internal {
+        Memory.Pointer ptr = Memory.getFreePointer();
         _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
+        Memory.setFreePointer(ptr);
     }
 
     /**
      * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
      * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
      */
     function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
+        Memory.Pointer ptr = Memory.getFreePointer();
         _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
+        Memory.setFreePointer(ptr);
     }
 
     /**
@@ -99,12 +106,13 @@ library SafeERC20 {
      * set here.
      */
     function forceApprove(IERC20 token, address spender, uint256 value) internal {
+        Memory.Pointer ptr = Memory.getFreePointer();
         bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
-
         if (!_callOptionalReturnBool(token, approvalCall)) {
             _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
             _callOptionalReturn(token, approvalCall);
         }
+        Memory.setFreePointer(ptr);
     }
 
     /**
@@ -171,21 +179,14 @@ library SafeERC20 {
      * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
      */
     function _callOptionalReturn(IERC20 token, bytes memory data) private {
-        uint256 returnSize;
-        uint256 returnValue;
-        assembly ("memory-safe") {
-            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
-            // bubble errors
-            if iszero(success) {
-                let ptr := mload(0x40)
-                returndatacopy(ptr, 0, returndatasize())
-                revert(ptr, returndatasize())
-            }
-            returnSize := returndatasize()
-            returnValue := mload(0)
+        (bool success, bytes32 returnValue) = LowLevelCall.callReturnBytes32(address(token), data);
+        uint256 returnSize = LowLevelCall.returnDataSize();
+
+        if (!success) {
+            LowLevelCall.bubbleRevert(data);
         }
 
-        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
+        if (returnSize == 0 ? address(token).code.length == 0 : uint256(returnValue) != 1) {
             revert SafeERC20FailedOperation(address(token));
         }
     }
@@ -199,14 +200,8 @@ library SafeERC20 {
      * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
      */
     function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
-        bool success;
-        uint256 returnSize;
-        uint256 returnValue;
-        assembly ("memory-safe") {
-            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
-            returnSize := returndatasize()
-            returnValue := mload(0)
-        }
-        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
+        (bool success, bytes32 returnValue) = LowLevelCall.callReturnBytes32(address(token), data);
+        uint256 returnSize = LowLevelCall.returnDataSize();
+        return success && (returnSize == 0 ? address(token).code.length > 0 : uint256(returnValue) == 1);
     }
 }

contracts/utils/Address.sol

@@ -4,11 +4,15 @@
 pragma solidity ^0.8.20;
 
 import {Errors} from "./Errors.sol";
+import {LowLevelCall} from "./LowLevelCall.sol";
+import {Memory} from "./Memory.sol";
 
 /**
  * @dev Collection of functions related to the address type
  */
 library Address {
+    using Memory for *;
+
     /**
      * @dev There's no code at `target` (it is not a contract).
      */
@@ -35,7 +39,8 @@ library Address {
             revert Errors.InsufficientBalance(address(this).balance, amount);
         }
 
-        (bool success, bytes memory returndata) = recipient.call{value: amount}("");
+        bool success = LowLevelCall.callRaw(recipient, "", amount);
+        bytes memory returndata = LowLevelCall.returnData();
         if (!success) {
             _revert(returndata);
         }
@@ -138,10 +143,7 @@ library Address {
     function _revert(bytes memory returndata) private pure {
         // Look for revert reason and bubble it up if present
         if (returndata.length > 0) {
-            // The easiest way to bubble the revert reason is using memory via assembly
-            assembly ("memory-safe") {
-                revert(add(returndata, 0x20), mload(returndata))
-            }
+            LowLevelCall.bubbleRevert(returndata.asPointer().addOffset(0x20).asBytes32());
         } else {
             revert Errors.FailedCall();
         }

contracts/utils/Create2.sol

@@ -4,6 +4,8 @@
 pragma solidity ^0.8.20;
 
 import {Errors} from "./Errors.sol";
+import {LowLevelCall} from "./LowLevelCall.sol";
+import {Memory} from "./Memory.sol";
 
 /**
  * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
@@ -43,15 +45,10 @@ library Create2 {
         }
         assembly ("memory-safe") {
             addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
-            // if no address was created, and returndata is not empty, bubble revert
-            if and(iszero(addr), not(iszero(returndatasize()))) {
-                let p := mload(0x40)
-                returndatacopy(p, 0, returndatasize())
-                revert(p, returndatasize())
-            }
         }
         if (addr == address(0)) {
-            revert Errors.FailedDeployment();
+            if (LowLevelCall.returnDataSize() != 0) LowLevelCall.bubbleRevert(LowLevelCall.returnData());
+            else revert Errors.FailedDeployment();
         }
     }