@1inch/solidity-utils 1.2.3 → 1.2.8

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/contracts/mocks/DaiLikePermitMock.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
+
+contract DaiLikePermitMock is ERC20Permit {
+	// bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address holder,address spender,uint256 nonce,uint256 expiry,bool allowed)");
+    bytes32 public constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;
+    
+    constructor(
+        string memory name,
+        string memory symbol,
+        address initialAccount,
+        uint256 initialBalance
+    ) payable ERC20(name, symbol) ERC20Permit(name) {
+        _mint(initialAccount, initialBalance);
+    }
+
+    function permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external
+    {
+        bytes32 digest =
+            keccak256(abi.encodePacked(
+                "\x19\x01",
+                this.DOMAIN_SEPARATOR(),
+                keccak256(abi.encode(PERMIT_TYPEHASH,
+                                     holder,
+                                     spender,
+                                     nonce,
+                                     expiry,
+                                     allowed))
+        ));
+
+        require(holder != address(0), "Dai/invalid-address-0");
+        require(holder == ecrecover(digest, v, r, s), "Dai/invalid-permit");
+        // solhint-disable-next-line not-rely-on-time
+        require(expiry == 0 || block.timestamp <= expiry, "Dai/permit-expired");
+        require(nonce == nonces(holder), "Dai/invalid-nonce");
+        _useNonce(holder);
+        uint wad = allowed ? type(uint128).max : 0;
+        _approve(holder, spender, wad);
+        emit Approval(holder, spender, wad);
+    }
+}

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.3",
+  "version": "1.2.8",
   "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 && shx cp README.md ./dist && shx cp -R ./contracts ./dist/contracts && shx 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 && shx mkdir -p dist/contracts/mocks && shx cp ./contracts/mocks/DaiLikePermitMock.sol dist/contracts/mocks/",
     "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"
 }