@1inch/solidity-utils 2.0.24 → 2.1.0

package/contracts/interfaces/IERC20MetadataUppercase.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+pragma abicoder v1;
+
+
+interface IERC20MetadataUppercase {
+    function NAME() external view returns (string memory);  // solhint-disable-line func-name-mixedcase
+    function SYMBOL() external view returns (string memory);  // solhint-disable-line func-name-mixedcase
+}

package/contracts/libraries/ECDSA.sol

@@ -16,6 +16,8 @@ library ECDSA {
     // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
     // these malleable signatures as well.
     uint256 private constant _S_BOUNDARY = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0 + 1;
+    uint256 private constant _COMPACT_S_MASK = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
+    uint256 private constant _COMPACT_V_SHIFT = 255;
 
     function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal view returns(address signer) {
         /// @solidity memory-safe-assembly
@@ -37,12 +39,12 @@ library ECDSA {
     function recover(bytes32 hash, bytes32 r, bytes32 vs) internal view returns(address signer) {
         /// @solidity memory-safe-assembly
         assembly { // solhint-disable-line no-inline-assembly
-            let s := shr(1, shl(1, vs))
+            let s := and(vs, _COMPACT_S_MASK)
             if lt(s, _S_BOUNDARY) {
                 let ptr := mload(0x40)
 
                 mstore(ptr, hash)
-                mstore(add(ptr, 0x20), add(27, shr(255, vs)))
+                mstore(add(ptr, 0x20), add(27, shr(_COMPACT_V_SHIFT, vs)))
                 mstore(add(ptr, 0x40), r)
                 mstore(add(ptr, 0x60), s)
                 mstore(0, 0)
@@ -52,30 +54,20 @@ library ECDSA {
         }
     }
 
+    /// @dev only compact signatures are supported see EIP-2098
     function recover(bytes32 hash, bytes calldata signature) internal view returns(address signer) {
         /// @solidity memory-safe-assembly
         assembly { // solhint-disable-line no-inline-assembly
-            let ptr := mload(0x40)
-
             // memory[ptr:ptr+0x80] = (hash, v, r, s)
-            switch signature.length
-            case 65 {
-                // memory[ptr+0x20:ptr+0x80] = (v, r, s)
-                mstore(add(ptr, 0x20), byte(0, calldataload(add(signature.offset, 0x40))))
-                calldatacopy(add(ptr, 0x40), signature.offset, 0x40)
-            }
-            case 64 {
+            if eq(signature.length, 64) {
+                let ptr := mload(0x40)
+
                 // memory[ptr+0x20:ptr+0x80] = (v, r, s)
                 let vs := calldataload(add(signature.offset, 0x20))
-                mstore(add(ptr, 0x20), add(27, shr(255, vs)))
+                mstore(add(ptr, 0x20), add(27, shr(_COMPACT_V_SHIFT, vs)))
                 calldatacopy(add(ptr, 0x40), signature.offset, 0x20)
-                mstore(add(ptr, 0x60), shr(1, shl(1, vs)))
-            }
-            default {
-                ptr := 0
-            }
+                mstore(add(ptr, 0x60), and(vs, _COMPACT_S_MASK))
 
-            if ptr {
                 if lt(mload(add(ptr, 0x60)), _S_BOUNDARY) {
                     // memory[ptr:ptr+0x20] = (hash)
                     mstore(ptr, hash)
@@ -90,7 +82,7 @@ library ECDSA {
 
     function recoverOrIsValidSignature(address signer, bytes32 hash, bytes calldata signature) internal view returns(bool success) {
         if (signer == address(0)) return false;
-        if ((signature.length == 64 || signature.length == 65) && recover(hash, signature) == signer) {
+        if (signature.length == 64 && recover(hash, signature) == signer) {
             return true;
         }
         return isValidSignature(signer, hash, signature);
@@ -133,9 +125,8 @@ library ECDSA {
             mstore(add(ptr, 0x24), 0x40)
             mstore(add(ptr, 0x44), signature.length)
             calldatacopy(add(ptr, 0x64), signature.offset, signature.length)
-            mstore(0, 0)
             if staticcall(gas(), signer, ptr, add(0x64, signature.length), 0, 0x20) {
-                success := eq(selector, mload(0))
+                success := and(eq(selector, mload(0)), eq(returndatasize(), 0x20))
             }
         }
     }
@@ -153,9 +144,8 @@ library ECDSA {
             mstore(add(ptr, 0x64), r)
             mstore(add(ptr, 0x84), s)
             mstore8(add(ptr, 0xa4), v)
-            mstore(0, 0)
             if staticcall(gas(), signer, ptr, 0xa5, 0, 0x20) {
-                success := eq(selector, mload(0))
+                success := and(eq(selector, mload(0)), eq(returndatasize(), 0x20))
             }
         }
     }
@@ -174,9 +164,8 @@ library ECDSA {
             mstore(add(ptr, 0x44), 64)
             mstore(add(ptr, 0x64), r)
             mstore(add(ptr, 0x84), vs)
-            mstore(0, 0)
-            if staticcall(gas(), signer, ptr, 0xa5, 0, 0x20) {
-                success := eq(selector, mload(0))
+            if staticcall(gas(), signer, ptr, 0xa4, 0, 0x20) {
+                success := and(eq(selector, mload(0)), eq(returndatasize(), 0x20))
             }
         }
     }
@@ -194,11 +183,10 @@ library ECDSA {
             mstore(add(ptr, 0x24), 0x40)
             mstore(add(ptr, 0x44), 65)
             mstore(add(ptr, 0x64), r)
-            mstore(add(ptr, 0x84), shr(1, shl(1, vs)))
-            mstore8(add(ptr, 0xa4), add(27, shr(255, vs)))
-            mstore(0, 0)
+            mstore(add(ptr, 0x84), and(vs, _COMPACT_S_MASK))
+            mstore8(add(ptr, 0xa4), add(27, shr(_COMPACT_V_SHIFT, vs)))
             if staticcall(gas(), signer, ptr, 0xa5, 0, 0x20) {
-                success := eq(selector, mload(0))
+                success := and(eq(selector, mload(0)), eq(returndatasize(), 0x20))
             }
         }
     }

package/contracts/libraries/StringUtil.sol

@@ -51,12 +51,12 @@ library StringUtil {
 
             result := mload(0x40)
             let length := mload(data)
-            let resultLength := add(mul(length, 2), 2)
-            let toPtr := add(result, 0x20)
+            let resultLength := shl(1, length)
+            let toPtr := add(result, 0x22)          // 32 bytes for length + 2 bytes for '0x'
             mstore(0x40, add(toPtr, resultLength))  // move free memory pointer
-            mstore(result, resultLength)
-            mstore(toPtr, 0x3078000000000000000000000000000000000000000000000000000000000000)  // set 0x as first two bytes
-            toPtr := add(toPtr, 0x02)
+            mstore(add(result, 2), 0x3078)          // 0x3078 is right aligned so we write to `result + 2`
+                                                    // to store the last 2 bytes in the beginning of the string
+            mstore(result, add(resultLength, 2))    // extra 2 bytes for '0x'
 
             for {
                 let fromPtr := add(data, 0x20)

package/contracts/libraries/UniERC20.sol

@@ -5,24 +5,21 @@ pragma abicoder v1;
 
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "../interfaces/IERC20MetadataUppercase.sol";
 import "./SafeERC20.sol";
 import "./StringUtil.sol";
 
-interface IERC20MetadataUppercase {
-    function NAME() external view returns (string memory);  // solhint-disable-line func-name-mixedcase
-    function SYMBOL() external view returns (string memory);  // solhint-disable-line func-name-mixedcase
-}
-
 library UniERC20 {
     using SafeERC20 for IERC20;
 
     error InsufficientBalance();
-    error ETHSendFailed();
     error ApproveCalledOnETH();
     error NotEnoughValue();
     error FromIsNotSender();
     error ToIsNotThis();
+    error ETHTransferFailed();
 
+    uint256 private constant _RAW_CALL_GAS_LIMIT = 5000;
     IERC20 private constant _ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
     IERC20 private constant _ZERO_ADDRESS = IERC20(address(0));
 
@@ -38,18 +35,21 @@ library UniERC20 {
         }
     }
 
+    /// @dev note that this function does nothing in case of zero amount
     function uniTransfer(IERC20 token, address payable to, uint256 amount) internal {
         if (amount > 0) {
             if (isETH(token)) {
                 if (address(this).balance < amount) revert InsufficientBalance();
-                (bool success, ) = to.call{value: amount}("");  // solhint-disable-line avoid-low-level-calls
-                if (!success) revert ETHSendFailed();
+                // solhint-disable-next-line avoid-low-level-calls
+                (bool success, ) = to.call{value: amount, gas: _RAW_CALL_GAS_LIMIT}("");
+                if (!success) revert ETHTransferFailed();
             } else {
                 token.safeTransfer(to, amount);
             }
         }
     }
 
+    /// @dev note that this function does nothing in case of zero amount
     function uniTransferFrom(IERC20 token, address payable from, address to, uint256 amount) internal {
         if (amount > 0) {
             if (isETH(token)) {
@@ -59,8 +59,9 @@ library UniERC20 {
                 if (msg.value > amount) {
                     // Return remainder if exist
                     unchecked {
-                        (bool success, ) = to.call{value: msg.value - amount}("");  // solhint-disable-line avoid-low-level-calls
-                        if (!success) revert ETHSendFailed();
+                        // solhint-disable-next-line avoid-low-level-calls
+                        (bool success, ) = from.call{value: msg.value - amount, gas: _RAW_CALL_GAS_LIMIT}("");
+                        if (!success) revert ETHTransferFailed();
                     }
                 }
             } else {
@@ -83,7 +84,9 @@ library UniERC20 {
         token.forceApprove(to, amount);
     }
 
-    function _uniDecode(IERC20 token, bytes4 lowerCaseSelector, bytes4 upperCaseSelector) private view returns(string memory) {
+    /// 20K gas is provided to account for possible implementations of name/symbol
+    /// (token implementation might be behind proxy or store the value in storage)
+    function _uniDecode(IERC20 token, bytes4 lowerCaseSelector, bytes4 upperCaseSelector) private view returns(string memory result) {
         if (isETH(token)) {
             return "ETH";
         }
@@ -97,10 +100,14 @@ library UniERC20 {
             );
         }
 
-        if (success && data.length >= 96) {
+        if (success && data.length >= 0x40) {
             (uint256 offset, uint256 len) = abi.decode(data, (uint256, uint256));
-            if (offset == 0x20 && len > 0 && len <= 256) {
-                return abi.decode(data, (string));
+            if (offset == 0x20 && len > 0 && data.length == 0x40 + len) {
+                /// @solidity memory-safe-assembly
+                assembly { // solhint-disable-line no-inline-assembly
+                    result := add(data, 0x20)
+                }
+                return result;
             }
         }
 
@@ -113,6 +120,7 @@ library UniERC20 {
             }
 
             if (len > 0) {
+                /// @solidity memory-safe-assembly
                 assembly { // solhint-disable-line no-inline-assembly
                     mstore(data, len)
                 }

package/contracts/mocks/ERC20PermitMock.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
+
+contract ERC20PermitMock is ERC20Permit {
+    constructor(
+        string memory name,
+        string memory symbol,
+        address initialAccount,
+        uint256 initialBalance
+    ) payable ERC20(name, symbol) ERC20Permit(name) {
+        _mint(initialAccount, initialBalance);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1inch/solidity-utils",
-  "version": "2.0.24",
+  "version": "2.1.0",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "repository": {