@1inch/solidity-utils 1.2.4 → 1.2.9

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/js/permit.js

@@ -0,0 +1,111 @@
+const { constants } = require('@openzeppelin/test-helpers');
+const ethSigUtil = require('eth-sig-util');
+const { fromRpcSig } = require('ethereumjs-util');
+
+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 },
+    };
+}
+
+/*
+ * @param permitContract The contract object with ERC20Permit type and token address for which the permit creating.
+ */
+async function getPermit (owner, ownerPrivateKey, permitContract, tokenVersion, chainId, spender, value, deadline = defaultDeadline) {
+    const nonce = await permitContract.nonces(owner);
+    const name = await permitContract.name();
+    const data = buildData(name, tokenVersion, chainId, permitContract.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);
+}
+
+/*
+ * @param permitContract The contract object with ERC20PermitLikeDai type and token address for which the permit creating.
+ */
+async function getPermitLikeDai (holder, holderPrivateKey, permitContract, tokenVersion, chainId, spender, allowed, expiry = defaultDeadline) {
+    const nonce = await permitContract.nonces(holder);
+    const name = await permitContract.name();
+    const data = buildDataLikeDai(name, tokenVersion, chainId, permitContract.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, options = {}, 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, options = {}, 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,8 +122,7 @@ async function gasspectEVM (txHash, options = {}, optionalTraceFile) {
         }
     }
 
-    const minOpGasCost = options.minOpGasCost ? options.minOpGasCost : 300;
-    const result = ops.filter(op => op.gasCost > minOpGasCost).map(op => op.traceAddress.join('-') + '-' + op.op +
+    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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1inch/solidity-utils",
-  "version": "1.2.4",
+  "version": "1.2.9",
   "main": "index.js",
   "repository": {
     "type": "git",