@1inch/solidity-utils 1.2.0 → 1.2.4

package/README.md

@@ -0,0 +1,47 @@
+<p align="center">
+  <img src="https://app.1inch.io/assets/images/logo.svg" width="200" alt="1inch network" />
+</p>
+
+# Utils library for contracts and tests
+
+[![Build Status](https://github.com/1inch/solidity-utils/workflows/CI/badge.svg)](https://github.com/1inch/solidity-utils/actions)
+[![Coverage Status](https://coveralls.io/repos/github/1inch/solidity-utils/badge.svg?branch=master)](https://coveralls.io/github/1inch/solidity-utils?branch=master)
+[![NPM Package](https://img.shields.io/npm/v/@1inch/solidity-utils.svg)](https://www.npmjs.org/package/@1inch/solidity-utils)
+
+### About
+
+This repository contains frequently used smart contracts, libraries and interfaces. Also it contains utils which are used in tests.
+
+### Solidity
+
+|directory|.sol|description|
+|--|--|--|
+|contracts|`EthReceiver`||
+|contracts|`Permitable`||
+|contracts|`GasChecker`||
+|contracts/interfaces|`IDaiLikePermit`|Interface of token which has `permit` method like DAI token|
+|contracts/interfaces|`IWETH`|WETH token interface|
+|contracts/libraries|`AddressArray`|library for work with array of addresses|
+|contracts/libraries|`AddressSet`|library for work with set of addresses|
+|contracts/libraries|`RevertReasonParser`|library parse the message from reverted method to readble format|
+|contracts/libraries|`StringUtil`|optimized methods to convert data to hex|
+|contracts/libraries|`UniERC20`||
+
+### JS
+
+|module|function|descrption|
+|--|--|--|
+|asserts|`assertThrowsAsync(action, msg)`|checks the async function `action()` thrown with message `msg`|
+|asserts|`assertRoughlyEqualValues(expected, actual, relativeDiff)`|checks the `expected` value is equal to `actual` value with `relativeDiff` precision|
+|utils|`timeIncreaseTo(seconds)`|increases blockchain time to `seconds` sec|
+|utils|`trackReceivedToken(token, wallet, txPromise, ...args)`|returns amount of `token` which recieved the `wallet` in async method `txPromise` with arguments `args`|
+|utils|`trackReceivedTokenAndTx(token, wallet, txPromise, ...args)`|returns transaction info and amount of `token` which recieved the `wallet` in async method `txPromise` with arguments `args`|
+|utils|`fixSignature(signature)`|patchs ganache's signature to geth's version|
+|utils|`signMessage(signer, messageHex) `|signs `messageHex` with `signer` and patchs ganache's signature to geth's version|
+|utils|`countInstructions(txHash, instruction)`|counts amount of `instruction` in transaction with `txHash` hash|
+|profileEVM|`profileEVM(txHash, instruction, optionalTraceFile)`|the same as the `countInstructions()` with option of writing all trace to `optionalTraceFile`|
+|profileEVM|`gasspectEVM(txHash, optionalTraceFile)`|returns all used operations in `txHash` transaction and their costs with option of writing all trace to `optionalTraceFile`|
+
+### UTILS
+
+...

package/contracts/EthReceiver.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+pragma abicoder v1;
+
+abstract contract EthReceiver {
+    receive() external payable {
+        // solhint-disable-next-line avoid-tx-origin
+        require(msg.sender != tx.origin, "ETH deposit rejected");
+    }
+}

package/contracts/GasChecker.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+pragma abicoder v1;
+
+import "@openzeppelin/contracts/utils/Strings.sol";
+
+contract GasChecker {
+    using Strings for uint256;
+    
+    modifier checkGasCost(uint256 expectedGasCost) {
+        uint256 gas = gasleft();
+        _;
+        gas -= gasleft();
+        if (expectedGasCost > 0) {
+            require (gas == expectedGasCost, string(abi.encodePacked("Gas cost differs: expected ", expectedGasCost.toString(), ", actual: ", gas.toString())));
+        }
+    }
+}

package/contracts/Permitable.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+pragma abicoder v1;
+
+import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol";
+import "./libraries/RevertReasonParser.sol";
+import "./interfaces/IDaiLikePermit.sol";
+
+contract Permitable {
+    function _permit(address token, bytes calldata permit) internal {
+        if (permit.length > 0) {
+            bool success;
+            bytes memory result;
+            if (permit.length == 32 * 7) {
+                // solhint-disable-next-line avoid-low-level-calls
+                (success, result) = token.call(abi.encodePacked(IERC20Permit.permit.selector, permit));
+            } else if (permit.length == 32 * 8) {
+                // solhint-disable-next-line avoid-low-level-calls
+                (success, result) = token.call(abi.encodePacked(IDaiLikePermit.permit.selector, permit));
+            } else {
+                revert("Wrong permit length");
+            }
+            if (!success) {
+                revert(RevertReasonParser.parse(result, "Permit failed: "));
+            }
+        }
+    }
+}

package/contracts/interfaces/IDaiLikePermit.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+
+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;
+}

package/contracts/interfaces/IWETH.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+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

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+
+library AddressArray {
+    struct Data {
+        mapping(uint256 => uint256) _raw;
+    }
+
+    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) {
+        return address(uint160(self._raw[i]));
+    }
+
+    function get(Data storage self) internal view returns(address[] memory arr) {
+        uint256 lengthAndFirst = self._raw[0];
+        uint256 len = lengthAndFirst >> 160;
+        arr = new address[](len);
+        if (len > 0) {
+            arr[0] = address(uint160(lengthAndFirst));
+            for (uint i = 1; i < len; i++) {
+                arr[i] = address(uint160(self._raw[i]));
+            }
+        }
+    }
+
+    function push(Data storage self, address account) internal returns(uint256) {
+        uint256 lengthAndFirst = self._raw[0];
+        uint256 len = lengthAndFirst >> 160;
+        if (len == 0) {
+            self._raw[0] = (1 << 160) + uint160(account);
+        }
+        else {
+            self._raw[0] = lengthAndFirst + (1 << 160);
+            self._raw[len] = uint160(account);
+        }
+        return len + 1;
+    }
+
+    function pop(Data storage self) internal {
+        uint256 lengthAndFirst = self._raw[0];
+        uint256 len = lengthAndFirst >> 160;
+        require(len > 0, "AddressArray: popping from empty");
+        self._raw[len - 1] = 0;
+        if (len > 1) {
+            self._raw[0] = lengthAndFirst - (1 << 160);
+        }
+    }
+
+    function set(Data storage self, uint256 index, address account) internal {
+        uint256 len = length(self);
+        require(index < len, "AddressArray: index out of range");
+
+        if (index == 0) {
+            self._raw[0] = (len << 160) | uint160(account);
+        }
+        else {
+            self._raw[index] = uint160(account);
+        }
+    }
+}

package/contracts/libraries/AddressSet.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "./AddressArray.sol";
+
+
+library AddressSet {
+    using AddressArray for AddressArray.Data;
+
+    struct Data {
+        AddressArray.Data items;
+        mapping(address => uint256) lookup;
+    }
+
+    function length(Data storage s) internal view returns(uint) {
+        return s.items.length();
+    }
+
+    function at(Data storage s, uint index) internal view returns(address) {
+        return s.items.at(index);
+    }
+
+    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) {
+        if (s.lookup[item] > 0) {
+            return false;
+        }
+        s.lookup[item] = s.items.push(item);
+        return true;
+    }
+
+    function remove(Data storage s, address item) internal returns(bool) {
+        uint index = s.lookup[item];
+        if (index == 0) {
+            return false;
+        }
+        if (index < s.items.length()) {
+            address lastItem = s.items.at(s.items.length() - 1);
+            s.items.set(index - 1, lastItem);
+            s.lookup[lastItem] = index;
+        }
+        s.items.pop();
+        delete s.lookup[item];
+        return true;
+    }
+}

package/contracts/libraries/RevertReasonParser.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+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
+  */
+library RevertReasonParser {
+    using StringUtil for uint256;
+    using StringUtil for bytes;
+    
+    bytes4 constant private _ERROR_SELECTOR = bytes4(keccak256("Error(string)"));
+    bytes4 constant private _PANIC_SELECTOR = bytes4(keccak256("Panic(uint256)"));
+
+    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)
+        bytes4 selector;
+        assembly {  // solhint-disable-line no-inline-assembly
+            selector := mload(add(data, 0x20))
+        }
+
+        // 68 = 4-byte selector + 32 bytes offset + 32 bytes length
+        if (selector == _ERROR_SELECTOR && data.length >= 68) {
+            string memory reason;
+            // solhint-disable no-inline-assembly
+            assembly {
+                // 68 = 32 bytes data length + 4-byte selector + 32 bytes offset
+                reason := add(data, 68)
+            }
+            /*
+                revert reason is padded up to 32 bytes with ABI encoder: Error(string)
+                also sometimes there is extra 32 bytes of zeros padded in the end:
+                https://github.com/ethereum/solidity/issues/10170
+                because of that we can't check for equality and instead check
+                that string length + extra 68 bytes is less than overall data length
+            */
+            require(data.length >= 68 + bytes(reason).length, "Invalid revert reason");
+            return string(abi.encodePacked(prefix, "Error(", reason, ")"));
+        }
+        // 36 = 4-byte selector + 32 bytes integer
+        else if (selector == _PANIC_SELECTOR && data.length == 36) {
+            uint256 code;
+            // solhint-disable no-inline-assembly
+            assembly {
+                // 36 = 32 bytes data length + 4-byte selector
+                code := mload(add(data, 36))
+            }
+            return string(abi.encodePacked(prefix, "Panic(", code.toHex(), ")"));
+        }
+        return string(abi.encodePacked(prefix, "Unknown(", data.toHex(), ")"));
+    }
+}

package/contracts/libraries/StringUtil.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+pragma abicoder v1;
+
+/// @title Library with gas-efficient string operations
+library StringUtil {
+    function toHex(uint256 value) internal pure returns (string memory) {
+        return toHex(abi.encodePacked(value));
+    }
+
+    function toHex(address value) internal pure returns (string memory) {
+        return toHex(abi.encodePacked(value));
+    }
+
+    function toHex(bytes memory data) internal pure returns (string memory result) {
+        // solhint-disable no-inline-assembly
+        assembly {
+            function _toHex16(input) -> output {
+                output := or(
+                    and(input, 0xFFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000),
+                    shr(64, and(input, 0x0000000000000000FFFFFFFFFFFFFFFF00000000000000000000000000000000))
+                )
+                output := or(
+                    and(output, 0xFFFFFFFF000000000000000000000000FFFFFFFF000000000000000000000000),
+                    shr(32, and(output, 0x00000000FFFFFFFF000000000000000000000000FFFFFFFF0000000000000000))
+                )
+                output := or(
+                    and(output, 0xFFFF000000000000FFFF000000000000FFFF000000000000FFFF000000000000),
+                    shr(16, and(output, 0x0000FFFF000000000000FFFF000000000000FFFF000000000000FFFF00000000))
+                )
+                output := or(
+                    and(output, 0xFF000000FF000000FF000000FF000000FF000000FF000000FF000000FF000000),
+                    shr(8, and(output, 0x00FF000000FF000000FF000000FF000000FF000000FF000000FF000000FF0000))
+                )
+                output := or(
+                    shr(4, and(output, 0xF000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000)),
+                    shr(8, and(output, 0x0F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F00))
+                )
+                output := add(
+                    add(0x3030303030303030303030303030303030303030303030303030303030303030, output),
+                    mul(
+                        and(
+                            shr(4, add(output, 0x0606060606060606060606060606060606060606060606060606060606060606)),
+                            0x0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F
+                        ),
+                        7   // Change 7 to 39 for lower case output
+                    )
+                )
+            }
+
+            result := mload(0x40)
+            let length := mload(data)
+            let resultLength := add(mul(length, 2), 2)
+            let toPtr := add(result, 0x20)
+            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)
+
+            for { 
+                let fromPtr := add(data, 0x20)
+                let endPtr := add(fromPtr, length)
+            } lt(fromPtr, endPtr) { 
+                fromPtr := add(fromPtr, 0x20)
+            } {
+                let rawData := mload(fromPtr)
+                let hexData := _toHex16(rawData)
+                mstore(toPtr, hexData)
+                toPtr := add(toPtr, 0x20)
+                hexData := _toHex16(shl(128, rawData))
+                mstore(toPtr, hexData)
+                toPtr := add(toPtr, 0x20)
+            }
+        }
+    }
+}

package/contracts/libraries/UniERC20.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+pragma abicoder v1;
+
+import "@openzeppelin/contracts/utils/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "./RevertReasonParser.sol";
+
+library UniERC20 {
+    using SafeMath for uint256;
+    using SafeERC20 for IERC20;
+
+    IERC20 private constant _ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
+    IERC20 private constant _ZERO_ADDRESS = IERC20(address(0));
+
+    function isETH(IERC20 token) internal pure returns (bool) {
+        return (token == _ZERO_ADDRESS || token == _ETH_ADDRESS);
+    }
+
+    function uniBalanceOf(IERC20 token, address account) internal view returns (uint256) {
+        if (isETH(token)) {
+            return account.balance;
+        } else {
+            return token.balanceOf(account);
+        }
+    }
+
+    function uniTransfer(IERC20 token, address payable to, uint256 amount) internal {
+        if (amount > 0) {
+            if (isETH(token)) {
+                to.transfer(amount);
+            } else {
+                token.safeTransfer(to, amount);
+            }
+        }
+    }
+
+    function uniApprove(IERC20 token, address to, uint256 amount) internal {
+        require(!isETH(token), "Approve called on ETH");
+
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, bytes memory returndata) = address(token).call(abi.encodeWithSelector(token.approve.selector, to, amount));
+
+        if (!success || (returndata.length > 0 && !abi.decode(returndata, (bool)))) {
+            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, to, 0));
+            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, to, amount));
+        }
+    }
+
+    function _callOptionalReturn(IERC20 token, bytes memory data) private {
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, bytes memory result) = address(token).call(data);
+        if (!success) {
+            revert(RevertReasonParser.parse(result, "Low-level call failed: "));
+        }
+
+        if (result.length > 0) { // Return data is optional
+            require(abi.decode(result, (bool)), "ERC20 operation did not succeed");
+        }
+    }
+}

package/js/asserts.js

@@ -1,34 +1,34 @@
-const { expect } = require('chai');
-const { BN } = require('@openzeppelin/test-helpers');
-
-async function assertThrowsAsync (action, msg) {
-    try {
-        await action();
-    } catch (e) {
-        expect(e.message).to.contain(msg);
-        return;
-    }
-    throw new Error('Should have thrown an error but didn\'t');
-}
-
-function assertRoughlyEqualValues (expected, actual, relativeDiff) {
-    const expectedBN = new BN(expected);
-    const actualBN = new BN(actual);
-
-    let multiplerNumerator = relativeDiff;
-    let multiplerDenominator = new BN('1');
-    while (!Number.isInteger(multiplerNumerator)) {
-        multiplerDenominator = multiplerDenominator.mul(new BN('10'));
-        multiplerNumerator *= 10;
-    }
-    const diff = expectedBN.sub(actualBN).abs();
-    const treshold = expectedBN.mul(new BN(multiplerNumerator.toString())).div(multiplerDenominator);
-    if (!diff.lte(treshold)) {
-        expect(actualBN).to.be.bignumber.equal(expectedBN, `${actualBN} != ${expectedBN} with ${relativeDiff} precision`);
-    }
-}
-
-module.exports = {
-    assertThrowsAsync,
-    assertRoughlyEqualValues,
-};
+const { expect } = require('chai');
+const { BN } = require('@openzeppelin/test-helpers');
+
+async function assertThrowsAsync (action, msg) {
+    try {
+        await action();
+    } catch (e) {
+        expect(e.message).to.contain(msg);
+        return;
+    }
+    throw new Error('Should have thrown an error but didn\'t');
+}
+
+function assertRoughlyEqualValues (expected, actual, relativeDiff) {
+    const expectedBN = new BN(expected);
+    const actualBN = new BN(actual);
+
+    let multiplerNumerator = relativeDiff;
+    let multiplerDenominator = new BN('1');
+    while (!Number.isInteger(multiplerNumerator)) {
+        multiplerDenominator = multiplerDenominator.mul(new BN('10'));
+        multiplerNumerator *= 10;
+    }
+    const diff = expectedBN.sub(actualBN).abs();
+    const treshold = expectedBN.mul(new BN(multiplerNumerator.toString())).div(multiplerDenominator);
+    if (!diff.lte(treshold)) {
+        expect(actualBN).to.be.bignumber.equal(expectedBN, `${actualBN} != ${expectedBN} with ${relativeDiff} precision`);
+    }
+}
+
+module.exports = {
+    assertThrowsAsync,
+    assertRoughlyEqualValues,
+};