@1inch/solidity-utils 1.2.2 → 1.2.7

package/README.md

@@ -40,7 +40,7 @@ This repository contains frequently used smart contracts, libraries and interfac
 |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`|
+|profileEVM|`gasspectEVM(txHash, options, optionalTraceFile)`|returns all used operations in `txHash` transaction with `options` and their costs with option of writing all trace to `optionalTraceFile`|
 
 ### UTILS
 

package/contracts/libraries/AddressArray.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.9;
+pragma solidity ^0.8.0;
 
 
 library AddressArray {

package/contracts/libraries/AddressSet.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.9;
+pragma solidity ^0.8.0;
 
 import "./AddressArray.sol";
 

package/js/permit.js

@@ -0,0 +1,110 @@
+const { constants } = require('@openzeppelin/test-helpers');
+const ethSigUtil = require('eth-sig-util');
+const { fromRpcSig } = require('ethereumjs-util');
+const { artifacts } = require('hardhat');
+const ERC20Permit = artifacts.require('@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol:ERC20Permit');
+const ERC20PermitLikeDai = artifacts.require('DaiLikePermitMock');
+
+const defaultDeadline = constants.MAX_UINT256;
+
+const EIP712Domain = [
+    { name: 'name', type: 'string' },
+    { name: 'version', type: 'string' },
+    { name: 'chainId', type: 'uint256' },
+    { name: 'verifyingContract', type: 'address' },
+];
+
+const Permit = [
+    { name: 'owner', type: 'address' },
+    { name: 'spender', type: 'address' },
+    { name: 'value', type: 'uint256' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'deadline', type: 'uint256' },
+];
+
+const DaiLikePermit = [
+    { name: 'holder', type: 'address' },
+    { name: 'spender', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'expiry', type: 'uint256' },
+    { name: 'allowed', type: 'bool' },
+];
+
+function trim0x (bigNumber) {
+    const s = bigNumber.toString();
+    if (s.startsWith('0x')) {
+        return s.substring(2);
+    }
+    return s;
+}
+
+function cutSelector (data) {
+    const hexPrefix = '0x';
+    return hexPrefix + data.substr(hexPrefix.length + 8);
+}
+
+function domainSeparator (name, version, chainId, verifyingContract) {
+    return '0x' + ethSigUtil.TypedDataUtils.hashStruct(
+        'EIP712Domain',
+        { name, version, chainId, verifyingContract },
+        { EIP712Domain },
+    ).toString('hex');
+}
+
+function buildData (name, version, chainId, verifyingContract, owner, spender, value, nonce, deadline = defaultDeadline) {
+    return {
+        primaryType: 'Permit',
+        types: { EIP712Domain, Permit },
+        domain: { name, version, chainId, verifyingContract },
+        message: { owner, spender, value, nonce, deadline },
+    };
+}
+
+function buildDataLikeDai (name, version, chainId, verifyingContract, holder, spender, nonce, allowed, expiry = defaultDeadline) {
+    return {
+        primaryType: 'Permit',
+        types: { EIP712Domain, Permit: DaiLikePermit },
+        domain: { name, version, chainId, verifyingContract },
+        message: { holder, spender, nonce, expiry, allowed },
+    };
+}
+
+async function getPermit (owner, ownerPrivateKey, token, tokenVersion, chainId, spender, value, deadline = defaultDeadline) {
+    const permitContract = await ERC20Permit.at(token.address);
+    const nonce = await permitContract.nonces(owner);
+    const name = await permitContract.name();
+    const data = buildData(name, tokenVersion, chainId, token.address, owner, spender, value, nonce, deadline);
+    const signature = ethSigUtil.signTypedMessage(Buffer.from(trim0x(ownerPrivateKey), 'hex'), { data });
+    const { v, r, s } = fromRpcSig(signature);
+    const permitCall = permitContract.contract.methods.permit(owner, spender, value, deadline, v, r, s).encodeABI();
+    return cutSelector(permitCall);
+}
+
+async function getPermitLikeDai (holder, holderPrivateKey, token, tokenVersion, chainId, spender, allowed, expiry = defaultDeadline) {
+    const permitContract = await ERC20PermitLikeDai.at(token.address);
+    const nonce = await permitContract.nonces(holder);
+    const name = await permitContract.name();
+    const data = buildDataLikeDai(name, tokenVersion, chainId, token.address, holder, spender, nonce, allowed, expiry);
+    const signature = ethSigUtil.signTypedMessage(Buffer.from(trim0x(holderPrivateKey), 'hex'), { data });
+    const { v, r, s } = fromRpcSig(signature);
+    const permitCall = permitContract.contract.methods.permit(holder, spender, nonce, expiry, allowed, v, r, s).encodeABI();
+    return cutSelector(permitCall);
+}
+
+function withTarget (target, data) {
+    return target.toString() + trim0x(data);
+}
+
+module.exports = {
+    defaultDeadline,
+    EIP712Domain,
+    Permit,
+    DaiLikePermit,
+    trim0x,
+    domainSeparator,
+    buildData,
+    buildDataLikeDai,
+    getPermit,
+    getPermitLikeDai,
+    withTarget,
+};

package/js/profileEVM.js

@@ -1,23 +1,74 @@
 const { promisify } = require('util');
 const fs = require('fs').promises;
 
-function _normalizeOp (op) {
-    if (op.op === 'STATICCALL') {
-        if (op.stack.length > 8 && op.stack[op.stack.length - 8] === '0000000000000000000000000000000000000000000000000000000000000001') {
-            op.gasCost = 700 + 3000;
-            op.op = 'STATICCALL-ECRECOVER';
-        } else if (op.stack.length > 8 && op.stack[op.stack.length - 8] <= '00000000000000000000000000000000000000000000000000000000000000FF') {
-            op.gasCost = 700;
-            op.op = 'STATICCALL-' + op.stack[op.stack.length - 8].substr(62, 2);
+const gasspectOptionsDefault = {
+    minOpGasCost: 300, // minimal gas cost of returned operations
+    args: false, // return operations arguments
+    res: false, // return operations results
+};
+
+function _normalizeOp (ops, i) {
+    if (ops[i].op === 'STATICCALL') {
+        ops[i].gasCost = ops[i].gasCost - ops[i + 1].gas;
+
+        if (ops[i].stack.length > 8 && ops[i].stack[ops[i].stack.length - 8] === '0000000000000000000000000000000000000000000000000000000000000001') {
+            ops[i].op = 'STATICCALL-ECRECOVER';
+        } else if (ops[i].stack.length > 8 && ops[i].stack[ops[i].stack.length - 8] <= '00000000000000000000000000000000000000000000000000000000000000FF') {
+            ops[i].op = 'STATICCALL-' + ops[i].stack[ops[i].stack.length - 8].substr(62, 2);
         } else {
-            op.gasCost = 700;
+            ops[i].args = [
+                '0x' + ops[i].stack[ops[i].stack.length - 2].substr(24),
+                '0x' + (ops[i].memory || []).join('').substr(
+                    2 * web3.utils.toBN(ops[i].stack[ops[i].stack.length - 3]).toNumber(),
+                    2 * web3.utils.toBN(ops[i].stack[ops[i].stack.length - 4]).toNumber(),
+                ),
+            ];
+            if (ops[i].gasCost === 100) {
+                ops[i].op += '_R';
+            }
         }
     }
-    if (['CALL', 'DELEGATECALL', 'CALLCODE'].indexOf(op.op) !== -1) {
-        op.gasCost = 700;
+    if (['CALL', 'DELEGATECALL', 'CALLCODE'].indexOf(ops[i].op) !== -1) {
+        ops[i].args = [
+            '0x' + ops[i].stack[ops[i].stack.length - 2].substr(24),
+            '0x' + (ops[i].memory || []).join('').substr(
+                2 * web3.utils.toBN(ops[i].stack[ops[i].stack.length - 4]).toNumber(),
+                2 * web3.utils.toBN(ops[i].stack[ops[i].stack.length - 5]).toNumber(),
+            ),
+        ];
+        ops[i].gasCost = ops[i].gasCost - ops[i + 1].gas;
+        ops[i].res = ops[i + 1].stack[ops[i + 1].stack.length - 1];
+
+        if (ops[i].gasCost === 100) {
+            ops[i].op += '_R';
+        }
     }
-    if (['RETURN', 'REVERT', 'INVALID'].indexOf(op.op) !== -1) {
-        op.gasCost = 3;
+    if (['RETURN', 'REVERT', 'INVALID'].indexOf(ops[i].op) !== -1) {
+        ops[i].gasCost = 3;
+    }
+    if (['SSTORE', 'SLOAD'].indexOf(ops[i].op) !== -1) {
+        ops[i].args = [
+            '0x' + ops[i].stack[ops[i].stack.length - 1],
+        ];
+        if (ops[i].op === 'SSTORE') {
+            ops[i].args.push('0x' + ops[i].stack[ops[i].stack.length - 2]);
+        }
+        if (ops[i].gasCost === 100) {
+            ops[i].op += '_R';
+        }
+        if (ops[i].gasCost === 20000) {
+            ops[i].op += '_I';
+        }
+
+        if (ops[i].op.startsWith('SLOAD')) {
+            ops[i].res = ops[i + 1].stack[ops[i + 1].stack.length - 1];
+        }
+    }
+    if (ops[i].op === 'EXTCODESIZE') {
+        ops[i].args = [
+            '0x' + ops[i].stack[ops[i].stack.length - 1].substr(24),
+        ];
+        ops[i].res = ops[i + 1].stack[ops[i + 1].stack.length - 1];
     }
 }
 
@@ -44,7 +95,9 @@ async function profileEVM (txHash, instruction, optionalTraceFile) {
     return str.split('"' + instruction.toUpperCase() + '"').length - 1;
 }
 
-async function gasspectEVM (txHash, optionalTraceFile) {
+async function gasspectEVM (txHash, options = gasspectOptionsDefault, optionalTraceFile) {
+    options = { ...gasspectOptionsDefault, ...options };
+
     const trace = await promisify(web3.currentProvider.send.bind(web3.currentProvider))({
         jsonrpc: '2.0',
         method: 'debug_traceTransaction',
@@ -55,9 +108,9 @@ async function gasspectEVM (txHash, optionalTraceFile) {
     const ops = trace.result.structLogs;
 
     const traceAddress = [0, -1];
-    for (const op of ops) {
+    for (const [i, op] of ops.entries()) {
         op.traceAddress = traceAddress.slice(0, traceAddress.length - 1);
-        _normalizeOp(op);
+        _normalizeOp(ops, i);
 
         if (op.depth + 2 > traceAddress.length) {
             traceAddress[traceAddress.length - 1] += 1;
@@ -69,7 +122,10 @@ async function gasspectEVM (txHash, optionalTraceFile) {
         }
     }
 
-    const result = ops.filter(op => op.gasCost > 300).map(op => op.traceAddress.join('-') + '-' + op.op + ' = ' + op.gasCost);
+    const result = ops.filter(op => op.gasCost > options.minOpGasCost).map(op => op.traceAddress.join('-') + '-' + op.op +
+                        (options.args ? '(' + (op.args || []).join(',') + ')' : '') +
+                        (options.res ? (op.res ? ':0x' + op.res : '') : '') +
+                        ' = ' + op.gasCost);
 
     if (optionalTraceFile) {
         await fs.writeFile(optionalTraceFile, JSON.stringify(result));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1inch/solidity-utils",
-  "version": "1.2.2",
+  "version": "1.2.7",
   "main": "index.js",
   "repository": {
     "type": "git",
@@ -8,28 +8,29 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@openzeppelin/contracts": "^4.3.2"
+    "@openzeppelin/contracts": "^4.4.0",
+    "ethereumjs-wallet": "^1.0.2"
   },
   "devDependencies": {
-    "@nomiclabs/hardhat-etherscan": "^2.1.6",
+    "@nomiclabs/hardhat-etherscan": "^2.1.8",
     "@nomiclabs/hardhat-truffle5": "^2.0.0",
     "@nomiclabs/hardhat-web3": "^2.0.0",
-    "@openzeppelin/test-helpers": "^0.5.13",
+    "@openzeppelin/test-helpers": "^0.5.15",
     "chai": "^4.3.4",
     "cross-spawn": "^7.0.3",
     "dotenv": "^10.0.0",
-    "eslint": "^7.32.0",
+    "eslint": "^8.3.0",
     "eslint-config-standard": "^16.0.3",
-    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-import": "^2.25.3",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^5.1.0",
+    "eslint-plugin-promise": "^5.1.1",
     "eslint-plugin-standard": "^5.0.0",
-    "hardhat": "^2.6.4",
-    "hardhat-deploy": "^0.9.2",
-    "hardhat-gas-reporter": "^1.0.4",
+    "hardhat": "^2.7.0",
+    "hardhat-deploy": "^0.9.14",
+    "hardhat-gas-reporter": "^1.0.6",
     "rimraf": "^3.0.2",
     "shx": "^0.3.3",
-    "solc": "^0.8.9",
+    "solc": "^0.8.10",
     "solhint": "^3.3.6",
     "solidity-coverage": "^0.7.17"
   },
@@ -37,7 +38,7 @@
     "solidity-utils-docify": "utils/docify.utils.js"
   },
   "scripts": {
-    "build": "rimraf ./dist && mkdir dist && shx cp -R js ./dist/js && shx cp -R utils ./dist/utils && shx cp package.json ./dist && cp -R ./contracts ./dist/contracts && rm -rf dist/contracts/mocks dist/contracts/tests",
+    "build": "rimraf ./dist && mkdir dist && shx cp -R js ./dist/js && shx cp -R utils ./dist/utils && shx cp package.json ./dist && shx cp README.md ./dist && shx cp -R ./contracts ./dist/contracts && shx rm -rf dist/contracts/mocks dist/contracts/tests",
     "coverage": "hardhat coverage",
     "lint": "yarn run lint:js && yarn run lint:sol",
     "lint:fix": "yarn run lint:js:fix && yarn run lint:sol:fix",
@@ -55,5 +56,5 @@
     "test": "test"
   },
   "author": "1inch",
-  "description": ""
+  "description": "Solidity and JS utils"
 }

package/.eslintignore

@@ -1,2 +0,0 @@
-node_modules/
-coverage/

package/.eslintrc

@@ -1,52 +0,0 @@
-{
-    "extends" : [
-      "standard",
-      "plugin:promise/recommended"
-    ],
-    "plugins": [
-      "promise"
-    ],
-    "env": {
-      "browser" : true,
-      "node"    : true,
-      "mocha"   : true,
-      "jest"    : true
-    },
-    "globals" : {
-      "artifacts": false,
-      "contract": false,
-      "assert": false,
-      "web3": false
-    },
-    "rules": {
-
-      // Strict mode
-      "strict": [2, "global"],
-
-      // Code style
-      "indent": [2, 4],
-      "quotes": [2, "single"],
-      "semi": ["error", "always"],
-      "space-before-function-paren": ["error", "always"],
-      "no-use-before-define": 0,
-      "no-unused-expressions": "off",
-      "eqeqeq": [2, "smart"],
-      "dot-notation": [2, {"allowKeywords": true, "allowPattern": ""}],
-      "no-redeclare": [2, {"builtinGlobals": true}],
-      "no-trailing-spaces": [2, { "skipBlankLines": true }],
-      "eol-last": 1,
-      "comma-spacing": [2, {"before": false, "after": true}],
-      "camelcase": [2, {"properties": "always"}],
-      "no-mixed-spaces-and-tabs": [2, "smart-tabs"],
-      "comma-dangle": [1, "always-multiline"],
-      "no-dupe-args": 2,
-      "no-dupe-keys": 2,
-      "no-debugger": 0,
-      "no-undef": 2,
-      "object-curly-spacing": [2, "always"],
-      "max-len": [2, 200, 2],
-      "generator-star-spacing": ["error", "before"],
-      "promise/avoid-new": 0,
-      "promise/always-return": 0
-    }
-  }

package/.github/workflows/ci.yml

@@ -1,86 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '16.x'
-
-      - run: npm install -g yarn
-
-      - id: yarn-cache
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - uses: actions/cache@v2
-        with:
-          path: ${{ steps.yarn-cache.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
-
-      - run: yarn
-      - run: yarn lint
-
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '16.x'
-
-      - run: npm install -g yarn
-
-      - id: yarn-cache
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - uses: actions/cache@v2
-        with:
-          path: ${{ steps.yarn-cache.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
-
-      - run: yarn
-      - run: yarn test
-
-  coverage:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-
-      - uses: actions/setup-node@v2
-        with:
-          node-version: 16.x
-
-      - run: npm install -g yarn
-
-      - id: yarn-cache
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - uses: actions/cache@v2
-        with:
-          path: ${{ steps.yarn-cache.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
-
-      - run: yarn
-      - run: yarn coverage
-
-      - name: Coveralls
-        uses: coverallsapp/github-action@v1.1.2
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}

package/.solcover.js

@@ -1,9 +0,0 @@
-module.exports = {
-    skipFiles: [
-        'mocks', 'tests'
-    ],
-    mocha: {
-        grep: "@skip-on-coverage",
-        invert: true
-    },
-}

package/.solhint.json

@@ -1,11 +0,0 @@
-{
-    "extends": "solhint:recommended",
-    "rules": {
-        "compiler-version": [
-            "error",
-            "^0.8.0"
-        ],
-        "private-vars-leading-underscore": "error",
-        "func-visibility": ["error", { "ignoreConstructors": true }]
-    }
-}

package/contracts/mocks/AddressArrayMock.sol

@@ -1,36 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity 0.8.9;
-
-import "../libraries/AddressArray.sol";
-
-
-contract AddressArrayMock {
-    using AddressArray for AddressArray.Data;
-    
-    AddressArray.Data private _self;
-
-    function length() external view returns(uint256) {
-        return AddressArray.length(_self);
-    }
-
-    function at(uint i) external view returns(address) {
-        return AddressArray.at(_self, i);
-    }
-
-    function get() external view returns(address[] memory arr) {
-        return AddressArray.get(_self);
-    }
-
-    function push(address account) external returns(uint256) {
-        return AddressArray.push(_self, account);
-    }
-
-    function pop() external {
-        AddressArray.pop(_self);
-    }
-
-    function set(uint256 index, address account) external {
-        AddressArray.set(_self, index, account);
-    }
-}

package/contracts/mocks/AddressSetMock.sol

@@ -1,32 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity 0.8.9;
-
-import "../libraries/AddressSet.sol";
-
-
-contract AddressSetMock {
-    using AddressSet for AddressSet.Data;
-
-    AddressSet.Data private _self;
-    
-    function length() external view returns(uint) {
-        return AddressSet.length(_self);
-    }
-
-    function at(uint index) external view returns(address) {
-        return AddressSet.at(_self, index);
-    }
-
-    function contains(address item) external view returns(bool) {
-        return AddressSet.contains(_self, item);
-    }
-
-    function add(address item) external returns(bool) {
-        return AddressSet.add(_self, item);
-    }
-
-    function remove(address item) external returns(bool) {
-        return AddressSet.remove(_self, item);
-    }
-}

package/contracts/mocks/TokenMock.sol

@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.0;
-pragma abicoder v1;
-
-import "@openzeppelin/contracts/access/Ownable.sol";
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-
-
-contract TokenMock is ERC20, Ownable {
-    // solhint-disable-next-line no-empty-blocks
-    constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
-
-    function mint(address account, uint256 amount) external onlyOwner {
-        _mint(account, amount);
-    }
-
-    function burn(address account, uint256 amount) external onlyOwner {
-        _burn(account, amount);
-    }
-}

package/contracts/mocks/libraries/StringUtilNaive.sol

@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.0;
-pragma abicoder v1;
-
-library StringUtilNaive {
-    bytes16 private constant _ALPHABET = 0x30313233343536373839616263646566;
-
-    function toHex(uint256 value) internal pure returns(string memory) {
-        return toHex(abi.encodePacked(value));
-    }
-
-    function toHex(bytes memory data) internal pure returns(string memory) {
-        unchecked {
-            bytes memory str = new bytes(2 + data.length * 2);
-            str[0] = "0";
-            str[1] = "x";
-            for (uint256 i = 0; i < data.length; i++) {
-                str[2 * i + 2] = _ALPHABET[uint8(data[i] >> 4)];
-                str[2 * i + 3] = _ALPHABET[uint8(data[i] & 0x0f)];
-            }
-            return string(str);
-        }
-    }
-}