more hex memory positions

Author: Amxx

contracts/metatx/ERC2771Forwarder.sol

@@ -287,7 +287,7 @@ contract ERC2771Forwarder is EIP712, Nonces {
             uint256 gasLeft;
 
             assembly ("memory-safe") {
-                success := call(reqGas, to, value, add(data, 0x20), mload(data), 0, 0)
+                success := call(reqGas, to, value, add(data, 0x20), mload(data), 0x00, 0x00)
                 gasLeft := gas()
             }
 
@@ -318,9 +318,9 @@ contract ERC2771Forwarder is EIP712, Nonces {
             // |-----------|----------|--------------------------------------------------------------------|
             // |           |          |                                                           result ↓ |
             // | 0x00:0x1F | selector | 0x0000000000000000000000000000000000000000000000000000000000000001 |
-            success := staticcall(gas(), target, add(encodedParams, 0x20), mload(encodedParams), 0, 0x20)
+            success := staticcall(gas(), target, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
             returnSize := returndatasize()
-            returnValue := mload(0)
+            returnValue := mload(0x00)
         }
 
         return success && returnSize >= 0x20 && returnValue > 0;

contracts/proxy/Proxy.sol

@@ -24,22 +24,22 @@ abstract contract Proxy {
             // Copy msg.data. We take full control of memory in this inline assembly
             // block because it will not return to Solidity code. We overwrite the
             // Solidity scratch pad at memory position 0.
-            calldatacopy(0, 0, calldatasize())
+            calldatacopy(0x00, 0x00, calldatasize())
 
             // Call the implementation.
             // out and outsize are 0 because we don't know the size yet.
-            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
+            let result := delegatecall(gas(), implementation, 0x00, calldatasize(), 0x00, 0x00)
 
             // Copy the returned data.
-            returndatacopy(0, 0, returndatasize())
+            returndatacopy(0x00, 0x00, returndatasize())
 
             switch result
             // delegatecall returns 0 on error.
             case 0 {
-                revert(0, returndatasize())
+                revert(0x00, returndatasize())
             }
             default {
-                return(0, returndatasize())
+                return(0x00, returndatasize())
             }
         }
     }

contracts/utils/LowLevelCall.sol

@@ -17,7 +17,7 @@ library LowLevelCall {
     /// @dev Same as {callNoReturn}, but allows to specify the value to be sent in the call.
     function callNoReturn(address target, uint256 value, bytes memory data) internal returns (bool success) {
         assembly ("memory-safe") {
-            success := call(gas(), target, value, add(data, 0x20), mload(data), 0, 0)
+            success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x00)
         }
     }
 
@@ -40,7 +40,7 @@ library LowLevelCall {
         bytes memory data
     ) internal returns (bool success, bytes32 result1, bytes32 result2) {
         assembly ("memory-safe") {
-            success := call(gas(), target, value, add(data, 0x20), mload(data), 0, 0x40)
+            success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x40)
             result1 := mload(0x00)
             result2 := mload(0x20)
         }
@@ -49,7 +49,7 @@ library LowLevelCall {
     /// @dev Performs a Solidity function call using a low level `staticcall` and ignoring the return data.
     function staticcallNoReturn(address target, bytes memory data) internal view returns (bool success) {
         assembly ("memory-safe") {
-            success := staticcall(gas(), target, add(data, 0x20), mload(data), 0, 0)
+            success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00)
         }
     }