@1inch/solidity-utils 2.1.0 → 2.1.2

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
-    <img src="https://github.com/1inch/farming/blob/master/.github/1inch_github_w.svg#gh-light-mode-only">
-    <img src="https://github.com/1inch/farming/blob/master/.github/1inch_github_b.svg#gh-dark-mode-only">
+    <img src="https://github.com/1inch/solidity-utils/blob/master/.github/1inch_github_w.svg#gh-light-mode-only">
+    <img src="https://github.com/1inch/solidity-utils/blob/master/.github/1inch_github_b.svg#gh-dark-mode-only">
 </div>
 
 # Utils library for contracts and tests
@@ -65,6 +65,66 @@ Add to `package.json` file solidity compiler version and shortcut to run command
 
 ...
 
+#### Dependencies list (imports-list)
+
+Lists all imports recursively for the given solidity contract file. 
+
+##### Usage
+```
+npx imports-list -i <solidity file> [-a <alias list>]
+```
+
+Available parameters
+```
+Options:
+  -i, --input <input>     file to get dependencies for
+  -a, --alias [alias...]  projects alias list
+  -h, --help              display help for command
+```
+Aliases are used to provide source code for third-party projects. 
+For example, your contract uses imports from your other project and import is defined as
+```
+import "@1inch/otherproject/contracts/dependency.sol";
+```
+and you've got source code for `@1inch/otherproject` locally. Then you provide local path for the project to rip dependencies from `dependency.sol` as well.
+If there are several dependencies they should be provided using space as separator. 
+
+##### Example
+File imports
+```Solidity
+#rootFile.sol
+import '@1inch/otherproject/contracts/dependency.sol'
+
+#@1inch/otherproject/contracts/dependency.sol
+import 'helpers/helper.sol'
+```
+File and folder structure
+```
+rootFolder/
+
+-- mainProject/
+---- contracts/
+------ rootFile.sol
+
+-- dependencyProject/
+---- helpers/
+------ helper.sol
+---- dependency.sol
+```
+Command
+```
+rootFolder/mainProject % npx imports-list -i './contracts/rootFile.sol' -a '@1inch/otherproject' '../dependencyProject'
+```
+Output
+```
+Project => root
+not set
+
+Project => @1inch/otherproject
+../otherproject/contracts/dependency.sol
+../otherproject/contracts/helpers/helper.sol
+```
+
 #### Test documentation generator (test-docgen)
 Script generates documentation for tests in markdown format.
 Give descriptions for `describe` and `it` sections and build documentation using these descriptions.

package/contracts/GasChecker.sol

@@ -9,7 +9,9 @@ contract GasChecker {
     modifier checkGasCost(uint256 expected) {
         uint256 gas = gasleft();
         _;
-        unchecked { gas -= gasleft(); }
+        unchecked {
+            gas -= gasleft();
+        }
         if (expected > 0 && gas != expected) revert GasCostDiffers(expected, gas);
     }
 }

package/contracts/OnlyWethReceiver.sol

@@ -6,7 +6,7 @@ pragma abicoder v1;
 import "./EthReceiver.sol";
 
 abstract contract OnlyWethReceiver is EthReceiver {
-    address private immutable _WETH;  // solhint-disable-line var-name-mixedcase
+    address private immutable _WETH; // solhint-disable-line var-name-mixedcase
 
     constructor(address weth) {
         _WETH = address(weth);

package/contracts/interfaces/IDaiLikePermit.sol

@@ -3,7 +3,15 @@
 pragma solidity ^0.8.0;
 pragma abicoder v1;
 
-
 interface IDaiLikePermit {
-    function permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external;
+    function permit(
+        address holder,
+        address spender,
+        uint256 nonce,
+        uint256 expiry,
+        bool allowed,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
 }

package/contracts/interfaces/IERC20MetadataUppercase.sol

@@ -3,8 +3,8 @@
 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
+    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/interfaces/IWETH.sol

@@ -5,8 +5,8 @@ pragma abicoder v1;
 
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
-
 interface IWETH is IERC20 {
     function deposit() external payable;
+
     function withdraw(uint256 amount) external;
 }

package/contracts/libraries/AddressArray.sol

@@ -3,40 +3,50 @@
 pragma solidity ^0.8.0;
 pragma abicoder v1;
 
+/// @title Library that implements address array on mapping, stores array length at 0 index.
 library AddressArray {
     error IndexOutOfBounds();
     error PopFromEmptyArray();
     error OutputArrayTooSmall();
 
+    /// @dev Data struct containing raw mapping.
     struct Data {
         mapping(uint256 => uint256) _raw;
     }
 
-    function length(Data storage self) internal view returns(uint256) {
+    /// @dev Length of array.
+    function length(Data storage self) internal view returns (uint256) {
         return self._raw[0] >> 160;
     }
 
-    function at(Data storage self, uint i) internal view returns(address) {
+    /// @dev Returns data item from `self` storage at `i`.
+    function at(Data storage self, uint256 i) internal view returns (address) {
         return address(uint160(self._raw[i]));
     }
 
-    function get(Data storage self) internal view returns(address[] memory arr) {
+    /// @dev Returns list of addresses from storage `self`.
+    function get(Data storage self) internal view returns (address[] memory arr) {
         uint256 lengthAndFirst = self._raw[0];
         arr = new address[](lengthAndFirst >> 160);
         _get(self, arr, lengthAndFirst);
     }
 
-    function get(Data storage self, address[] memory output) internal view returns(address[] memory) {
+    /// @dev Puts list of addresses from `self` storage into `output` array.
+    function get(Data storage self, address[] memory output) internal view returns (address[] memory) {
         return _get(self, output, self._raw[0]);
     }
 
-    function _get(Data storage self, address[] memory output, uint256 lengthAndFirst) private view returns(address[] memory) {
+    function _get(
+        Data storage self,
+        address[] memory output,
+        uint256 lengthAndFirst
+    ) private view returns (address[] memory) {
         uint256 len = lengthAndFirst >> 160;
         if (len > output.length) revert OutputArrayTooSmall();
         if (len > 0) {
             output[0] = address(uint160(lengthAndFirst));
             unchecked {
-                for (uint i = 1; i < len; i++) {
+                for (uint256 i = 1; i < len; i++) {
                     output[i] = address(uint160(self._raw[i]));
                 }
             }
@@ -44,14 +54,14 @@ library AddressArray {
         return output;
     }
 
-    function push(Data storage self, address account) internal returns(uint256) {
+    /// @dev Array push back `account` operation on storage `self`.
+    function push(Data storage self, address account) internal returns (uint256) {
         unchecked {
             uint256 lengthAndFirst = self._raw[0];
             uint256 len = lengthAndFirst >> 160;
             if (len == 0) {
                 self._raw[0] = (1 << 160) + uint160(account);
-            }
-            else {
+            } else {
                 self._raw[0] = lengthAndFirst + (1 << 160);
                 self._raw[len] = uint160(account);
             }
@@ -59,6 +69,7 @@ library AddressArray {
         }
     }
 
+    /// @dev Array pop back operation for storage `self`.
     function pop(Data storage self) internal {
         unchecked {
             uint256 lengthAndFirst = self._raw[0];
@@ -71,14 +82,18 @@ library AddressArray {
         }
     }
 
-    function set(Data storage self, uint256 index, address account) internal {
+    /// @dev Set element for storage `self` at `index` to `account`.
+    function set(
+        Data storage self,
+        uint256 index,
+        address account
+    ) internal {
         uint256 len = length(self);
         if (index >= len) revert IndexOutOfBounds();
 
         if (index == 0) {
             self._raw[0] = (len << 160) | uint160(account);
-        }
-        else {
+        } else {
             self._raw[index] = uint160(account);
         }
     }

package/contracts/libraries/AddressSet.sol

@@ -5,27 +5,40 @@ pragma abicoder v1;
 
 import "./AddressArray.sol";
 
+/** @title Library that is using AddressArray library for AddressArray.Data
+ * and allows Set operations on address storage data:
+ * 1. add
+ * 2. remove
+ * 3. contains
+ */
 library AddressSet {
     using AddressArray for AddressArray.Data;
 
+    /** @dev Data struct from AddressArray.Data items
+     * and lookup mapping address => index in data array.
+     */
     struct Data {
         AddressArray.Data items;
         mapping(address => uint256) lookup;
     }
 
-    function length(Data storage s) internal view returns(uint) {
+    /// @dev Length of data storage.
+    function length(Data storage s) internal view returns (uint256) {
         return s.items.length();
     }
 
-    function at(Data storage s, uint index) internal view returns(address) {
+    /// @dev Returns data item from `s` storage at `index`.
+    function at(Data storage s, uint256 index) internal view returns (address) {
         return s.items.at(index);
     }
 
-    function contains(Data storage s, address item) internal view returns(bool) {
+    /// @dev Returns true if storage `s` has `item`.
+    function contains(Data storage s, address item) internal view returns (bool) {
         return s.lookup[item] != 0;
     }
 
-    function add(Data storage s, address item) internal returns(bool) {
+    /// @dev Adds `item` into storage `s` and returns true if successful.
+    function add(Data storage s, address item) internal returns (bool) {
         if (s.lookup[item] > 0) {
             return false;
         }
@@ -33,8 +46,9 @@ library AddressSet {
         return true;
     }
 
-    function remove(Data storage s, address item) internal returns(bool) {
-        uint index = s.lookup[item];
+    /// @dev Removes `item` from storage `s` and returns true if successful.
+    function remove(Data storage s, address item) internal returns (bool) {
+        uint256 index = s.lookup[item];
         if (index == 0) {
             return false;
         }

package/contracts/libraries/ECDSA.sol

@@ -19,7 +19,12 @@ library ECDSA {
     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) {
+    function recover(
+        bytes32 hash,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) internal view returns (address signer) {
         /// @solidity memory-safe-assembly
         assembly { // solhint-disable-line no-inline-assembly
             if lt(s, _S_BOUNDARY) {
@@ -36,7 +41,11 @@ library ECDSA {
         }
     }
 
-    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal view returns(address signer) {
+    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 := and(vs, _COMPACT_S_MASK)
@@ -54,20 +63,37 @@ library ECDSA {
         }
     }
 
-    /// @dev only compact signatures are supported see EIP-2098
-    function recover(bytes32 hash, bytes calldata signature) internal view returns(address signer) {
+    /// @dev WARNING!!!
+    /// There is a known signature malleability issue with two representations of signatures!
+    /// Even though this function is able to verify both standard 65-byte and compact 64-byte EIP-2098 signatures
+    /// one should never use raw signatures for any kind of invalidation logic in their code.
+    /// As the standard and compact representations are interchangeable any invalidation logic that relies on
+    /// signature uniqueness will get rekt.
+    /// More info: https://github.com/OpenZeppelin/openzeppelin-contracts/security/advisories/GHSA-4h98-2769-gh6h
+    function recover(bytes32 hash, bytes calldata signature) internal view returns (address signer) {
         /// @solidity memory-safe-assembly
         assembly { // solhint-disable-line no-inline-assembly
-            // memory[ptr:ptr+0x80] = (hash, v, r, s)
-            if eq(signature.length, 64) {
-                let ptr := mload(0x40)
+            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 {
                 // memory[ptr+0x20:ptr+0x80] = (v, r, s)
                 let vs := calldataload(add(signature.offset, 0x20))
                 mstore(add(ptr, 0x20), add(27, shr(_COMPACT_V_SHIFT, vs)))
                 calldatacopy(add(ptr, 0x40), signature.offset, 0x20)
                 mstore(add(ptr, 0x60), and(vs, _COMPACT_S_MASK))
+            }
+            default {
+                ptr := 0
+            }
 
+            if ptr {
                 if lt(mload(add(ptr, 0x60)), _S_BOUNDARY) {
                     // memory[ptr:ptr+0x20] = (hash)
                     mstore(ptr, hash)
@@ -80,15 +106,25 @@ library ECDSA {
         }
     }
 
-    function recoverOrIsValidSignature(address signer, bytes32 hash, bytes calldata signature) internal view returns(bool success) {
+    function recoverOrIsValidSignature(
+        address signer,
+        bytes32 hash,
+        bytes calldata signature
+    ) internal view returns (bool success) {
         if (signer == address(0)) return false;
-        if (signature.length == 64 && recover(hash, signature) == signer) {
+        if ((signature.length == 64 || signature.length == 65) && recover(hash, signature) == signer) {
             return true;
         }
         return isValidSignature(signer, hash, signature);
     }
 
-    function recoverOrIsValidSignature(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal view returns(bool success) {
+    function recoverOrIsValidSignature(
+        address signer,
+        bytes32 hash,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) internal view returns (bool success) {
         if (signer == address(0)) return false;
         if (recover(hash, v, r, s) == signer) {
             return true;
@@ -96,7 +132,12 @@ library ECDSA {
         return isValidSignature(signer, hash, v, r, s);
     }
 
-    function recoverOrIsValidSignature(address signer, bytes32 hash, bytes32 r, bytes32 vs) internal view returns(bool success) {
+    function recoverOrIsValidSignature(
+        address signer,
+        bytes32 hash,
+        bytes32 r,
+        bytes32 vs
+    ) internal view returns (bool success) {
         if (signer == address(0)) return false;
         if (recover(hash, r, vs) == signer) {
             return true;
@@ -104,7 +145,12 @@ library ECDSA {
         return isValidSignature(signer, hash, r, vs);
     }
 
-    function recoverOrIsValidSignature65(address signer, bytes32 hash, bytes32 r, bytes32 vs) internal view returns(bool success) {
+    function recoverOrIsValidSignature65(
+        address signer,
+        bytes32 hash,
+        bytes32 r,
+        bytes32 vs
+    ) internal view returns (bool success) {
         if (signer == address(0)) return false;
         if (recover(hash, r, vs) == signer) {
             return true;
@@ -112,7 +158,11 @@ library ECDSA {
         return isValidSignature65(signer, hash, r, vs);
     }
 
-    function isValidSignature(address signer, bytes32 hash, bytes calldata signature) internal view returns(bool success) {
+    function isValidSignature(
+        address signer,
+        bytes32 hash,
+        bytes calldata signature
+    ) internal view returns (bool success) {
         // (bool success, bytes memory data) = signer.staticcall(abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature));
         // return success && data.length >= 4 && abi.decode(data, (bytes4)) == IERC1271.isValidSignature.selector;
         bytes4 selector = IERC1271.isValidSignature.selector;
@@ -131,7 +181,13 @@ library ECDSA {
         }
     }
 
-    function isValidSignature(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal view returns(bool success) {
+    function isValidSignature(
+        address signer,
+        bytes32 hash,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) internal view returns (bool success) {
         bytes4 selector = IERC1271.isValidSignature.selector;
         /// @solidity memory-safe-assembly
         assembly { // solhint-disable-line no-inline-assembly
@@ -150,7 +206,12 @@ library ECDSA {
         }
     }
 
-    function isValidSignature(address signer, bytes32 hash, bytes32 r, bytes32 vs) internal view returns(bool success) {
+    function isValidSignature(
+        address signer,
+        bytes32 hash,
+        bytes32 r,
+        bytes32 vs
+    ) internal view returns (bool success) {
         // (bool success, bytes memory data) = signer.staticcall(abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, abi.encodePacked(r, vs)));
         // return success && data.length >= 4 && abi.decode(data, (bytes4)) == IERC1271.isValidSignature.selector;
         bytes4 selector = IERC1271.isValidSignature.selector;
@@ -170,7 +231,12 @@ library ECDSA {
         }
     }
 
-    function isValidSignature65(address signer, bytes32 hash, bytes32 r, bytes32 vs) internal view returns(bool success) {
+    function isValidSignature65(
+        address signer,
+        bytes32 hash,
+        bytes32 r,
+        bytes32 vs
+    ) internal view returns (bool success) {
         // (bool success, bytes memory data) = signer.staticcall(abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, abi.encodePacked(r, vs & ~uint256(1 << 255), uint8(vs >> 255))));
         // return success && data.length >= 4 && abi.decode(data, (bytes4)) == IERC1271.isValidSignature.selector;
         bytes4 selector = IERC1271.isValidSignature.selector;

package/contracts/libraries/RevertReasonForwarder.sol

@@ -3,7 +3,9 @@
 pragma solidity ^0.8.0;
 pragma abicoder v1;
 
+/// @title Revert reason forwarder.
 library RevertReasonForwarder {
+    /// @dev Forwards latest externall call revert.
     function reRevert() internal pure {
         // bubble up revert reason from latest external call
         /// @solidity memory-safe-assembly

package/contracts/libraries/RevertReasonParser.sol

@@ -6,21 +6,22 @@ pragma abicoder v1;
 import "./StringUtil.sol";
 
 /** @title Library that allows to parse unsuccessful arbitrary calls revert reasons.
-  * See https://solidity.readthedocs.io/en/latest/control-structures.html#revert for details.
-  * Note that we assume revert reason being abi-encoded as Error(string) so it may fail to parse reason
-  * if structured reverts appear in the future.
-  *
-  * All unsuccessful parsings get encoded as Unknown(data) string
-  */
+ * See https://solidity.readthedocs.io/en/latest/control-structures.html#revert for details.
+ * Note that we assume revert reason being abi-encoded as Error(string) so it may fail to parse reason
+ * if structured reverts appear in the future.
+ *
+ * All unsuccessful parsings get encoded as Unknown(data) string
+ */
 library RevertReasonParser {
     using StringUtil for uint256;
     using StringUtil for bytes;
 
     error InvalidRevertReason();
 
-    bytes4 constant private _ERROR_SELECTOR = bytes4(keccak256("Error(string)"));
-    bytes4 constant private _PANIC_SELECTOR = bytes4(keccak256("Panic(uint256)"));
+    bytes4 private constant _ERROR_SELECTOR = bytes4(keccak256("Error(string)"));
+    bytes4 private constant _PANIC_SELECTOR = bytes4(keccak256("Panic(uint256)"));
 
+    /// @dev Parses error `data` and returns actual with `prefix`.
     function parse(bytes memory data, string memory prefix) internal pure returns (string memory) {
         // https://solidity.readthedocs.io/en/latest/control-structures.html#revert
         // We assume that revert reason is abi-encoded as Error(string)