@1inch/solidity-utils 1.2.1 → 1.2.5

package/hardhat.networks.js

@@ -1,48 +0,0 @@
-const networks = {};
-
-if (process.env.MAINNET_RPC_URL && process.env.MAINNET_PRIVATE_KEY) {
-    networks.mainnet = {
-        url: process.env.MAINNET_RPC_URL,
-        chainId: 1,
-        gasPrice: 25000000000,
-        accounts: [process.env.MAINNET_PRIVATE_KEY],
-    };
-}
-
-if (process.env.BSC_RPC_URL && process.env.BSC_PRIVATE_KEY) {
-    networks.bsc = {
-        url: process.env.BSC_RPC_URL,
-        chainId: 56,
-        gasPrice: 10000000000,
-        accounts: [process.env.BSC_PRIVATE_KEY],
-    };
-}
-
-if (process.env.KOVAN_RPC_URL && process.env.KOVAN_PRIVATE_KEY) {
-    networks.kovan = {
-        url: process.env.KOVAN_RPC_URL,
-        chainId: 42,
-        gasPrice: 1000000000,
-        accounts: [process.env.KOVAN_PRIVATE_KEY],
-    };
-}
-
-if (process.env.MATIC_RPC_URL && process.env.MATIC_PRIVATE_KEY) {
-    networks.matic = {
-        url: process.env.MATIC_RPC_URL,
-        chainId: 137,
-        gasPrice: 1000000000,
-        accounts: [process.env.MATIC_PRIVATE_KEY],
-    };
-}
-
-if (process.env.ARBITRUM_RPC_URL && process.env.ARBITRUM_PRIVATE_KEY) {
-    networks.arbitrum = {
-        url: process.env.ARBITRUM_RPC_URL,
-        chainId: 42161,
-        gasPrice: 250000000,
-        accounts: [process.env.ARBITRUM_PRIVATE_KEY],
-    };
-}
-
-module.exports = networks;

package/test/asserts.js

@@ -1,88 +0,0 @@
-const { expect } = require('chai');
-const { assertThrowsAsync, assertRoughlyEqualValues } = require('../js/asserts.js');
-
-describe('assertThrowsAsync', async function () {
-    async function action () {
-        throw new Error('Test throw message');
-    }
-
-    it('shouldn\'t be thrown', async function () {
-        try {
-            await assertThrowsAsync(action, 'Test throw message');
-        } catch (e) {
-            expect(true).equal(false);
-        }
-    });
-
-    it('should be thrown with no expected message', async function () {
-        try {
-            await assertThrowsAsync(action, 'Another test throw message');
-        } catch (e) {
-            expect(e.message).equal('expected \'Test throw message\' to include \'Another test throw message\'');
-            return;
-        }
-        expect(true).equal(false);
-    });
-
-    it('should be thrown because function doesn\'t have throw', async function () {
-        try {
-            await assertThrowsAsync(async function () {}, 'Test throw message');
-        } catch (e) {
-            expect(e.message).equal('Should have thrown an error but didn\'t');
-            return;
-        }
-        expect(true).equal(false);
-    });
-});
-
-describe('assertRoughlyEqualValues', async function () {
-    function shouldNotThrow (expected, actual, relativeDiff) {
-        try {
-            assertRoughlyEqualValues(expected, actual, relativeDiff);
-        } catch (e) {
-            expect(true).equal(false);
-        }
-    }
-
-    function shouldThrow (expected, actual, relativeDiff) {
-        try {
-            assertRoughlyEqualValues(expected, actual, relativeDiff);
-        } catch (e) {
-            expect(e.message).equal(`${actual} != ${expected} with ${relativeDiff} precision: expected '${actual}' to equal '${expected}'`);
-            return;
-        }
-        expect(true).equal(false);
-    }
-
-    it('should be work with expected = actual, any relativeDiff', async function () {
-        shouldNotThrow(1000000, 1000000, 0.000001);
-    });
-
-    it('should be work with expected = actual, relativeDiff = 0', async function () {
-        shouldNotThrow(1000000, 1000000, 0);
-    });
-
-    it('should be work with diff between expected and actual less than relativeDiff * expected', async function () {
-        shouldNotThrow(1000001, 1000000, 1.000001);
-    });
-
-    it('should be work with negative diff between expected and actual less than relativeDiff * expected', async function () {
-        shouldNotThrow(1000000, 1000001, 0.000001);
-    });
-
-    it('should be work with diff between expected and actual equals to relativeDiff', async function () {
-        shouldNotThrow(1000000, 1000001, 1);
-    });
-
-    it('should be thrown with expected != actual with relativeDiff = 0', async function () {
-        shouldThrow(1000000, 1000001, 0);
-    });
-
-    it('should be thrown with expected > actual more than relativeDiff * expected', async function () {
-        shouldThrow(1000001, 1000000, 0.0000001);
-    });
-
-    it('should be thrown with expected < actual more than relativeDiff * expected', async function () {
-        shouldThrow(1000000, 1000001, 0.0000001);
-    });
-});

package/test/libraries/AddressArray.js

@@ -1,149 +0,0 @@
-const { expect } = require('chai');
-const { expectRevert, constants } = require('@openzeppelin/test-helpers');
-
-const AddressArrayMock = artifacts.require('AddressArrayMock');
-
-contract('AddressArray', async function ([wallet1, wallet2, wallet3]) {
-    beforeEach(async function () {
-        this.AddressArrayMock = await AddressArrayMock.new();
-    });
-
-    describe('length', async function () {
-        it('should be calculate length 0', async function () {
-            expect(await this.AddressArrayMock.length()).to.be.bignumber.equal('0');
-        });
-
-        it('should be calculate length 1', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            expect(await this.AddressArrayMock.length()).to.be.bignumber.equal('1');
-        });
-    });
-
-    describe('at', async function () {
-        it('should be get from empty data', async function () {
-            expect(await this.AddressArrayMock.at(0)).to.be.equal(constants.ZERO_ADDRESS);
-            expect(await this.AddressArrayMock.at(1)).to.be.equal(constants.ZERO_ADDRESS);
-        });
-
-        it('should be get from data with 1 element', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            expect(await this.AddressArrayMock.at(0)).to.be.equal(wallet1);
-            expect(await this.AddressArrayMock.at(1)).to.be.equal(constants.ZERO_ADDRESS);
-        });
-
-        it('should be get from data with several elements', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            await this.AddressArrayMock.push(wallet2);
-            expect(await this.AddressArrayMock.at(0)).to.be.equal(wallet1);
-            expect(await this.AddressArrayMock.at(1)).to.be.equal(wallet2);
-        });
-    });
-
-    describe('get', async function () {
-        it('should be get empty data', async function () {
-            expect(await this.AddressArrayMock.get()).to.eql([]);
-        });
-
-        it('should be get from data with 1 element', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            expect(await this.AddressArrayMock.get()).to.eql([wallet1]);
-        });
-
-        it('should be get from data with several elements', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            await this.AddressArrayMock.push(wallet2);
-            expect(await this.AddressArrayMock.get()).to.eql([wallet1, wallet2]);
-        });
-    });
-
-    describe('push', async function () {
-        it('should be push to empty data', async function () {
-            const pushedIndex = await this.AddressArrayMock.push.call(wallet1);
-            await this.AddressArrayMock.push(wallet1);
-            expect(await this.AddressArrayMock.at(pushedIndex - 1)).to.be.equal(wallet1);
-        });
-
-        it('should be push to data with 1 element', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            const pushedIndex = await this.AddressArrayMock.push.call(wallet2);
-            await this.AddressArrayMock.push(wallet2);
-            expect(await this.AddressArrayMock.at(pushedIndex - 1)).to.be.equal(wallet2);
-        });
-
-        it('should be get push to data with several elements', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            await this.AddressArrayMock.push(wallet2);
-            const pushedIndex = await this.AddressArrayMock.push.call(wallet3);
-            await this.AddressArrayMock.push(wallet3);
-            expect(await this.AddressArrayMock.at(pushedIndex - 1)).to.be.equal(wallet3);
-        });
-    });
-
-    describe('pop', async function () {
-        it('should be thrown when data is empty', async function () {
-            await expectRevert(
-                this.AddressArrayMock.pop(),
-                'AddressArray: popping from empty',
-            );
-        });
-
-        it('should be pop in data with 1 element', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            await this.AddressArrayMock.pop();
-            expect(await this.AddressArrayMock.get()).to.eql([]);
-        });
-
-        it('should be pop in data with several elements', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            await this.AddressArrayMock.push(wallet2);
-            await this.AddressArrayMock.pop();
-            expect(await this.AddressArrayMock.get()).to.eql([wallet1]);
-        });
-
-        it('should be several pops', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            await this.AddressArrayMock.push(wallet2);
-            await this.AddressArrayMock.push(wallet3);
-            await this.AddressArrayMock.pop();
-            expect(await this.AddressArrayMock.get()).to.eql([wallet1, wallet2]);
-        });
-
-        it('should be thrown when pops more than elements', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            await this.AddressArrayMock.pop();
-            await expectRevert(
-                this.AddressArrayMock.pop(),
-                'AddressArray: popping from empty',
-            );
-        });
-    });
-
-    describe('set', async function () {
-        it('should be thrown when set index less than data length', async function () {
-            await expectRevert(
-                this.AddressArrayMock.set(0, wallet1),
-                'AddressArray: index out of range',
-            );
-        });
-
-        it('should be set to index 0 to data with 1 element', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            await this.AddressArrayMock.set(0, wallet2);
-            expect(await this.AddressArrayMock.get()).to.eql([wallet2]);
-        });
-
-        it('should be set to index 0 to data with several elements', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            await this.AddressArrayMock.push(wallet2);
-            await this.AddressArrayMock.set(0, wallet3);
-            expect(await this.AddressArrayMock.get()).to.eql([wallet3, wallet2]);
-        });
-
-        it('should be set to index non-0 to data with several elements', async function () {
-            await this.AddressArrayMock.push(wallet1);
-            await this.AddressArrayMock.push(wallet2);
-            await this.AddressArrayMock.set(1, wallet3);
-            expect(await this.AddressArrayMock.get()).to.eql([wallet1, wallet3]);
-        });
-    });
-});

package/test/libraries/AddressSet.js

@@ -1,122 +0,0 @@
-const { expect } = require('chai');
-const { constants } = require('@openzeppelin/test-helpers');
-
-const AddressSetMock = artifacts.require('AddressSetMock');
-
-contract('AddressSet', async function ([wallet1, wallet2, wallet3]) {
-    beforeEach(async function () {
-        this.AddressSetMock = await AddressSetMock.new();
-    });
-
-    describe('length', async function () {
-        it('should be calculate length 0', async function () {
-            expect(await this.AddressSetMock.length()).to.be.bignumber.equal('0');
-        });
-
-        it('should be calculate length 1', async function () {
-            await this.AddressSetMock.add(wallet1);
-            expect(await this.AddressSetMock.length()).to.be.bignumber.equal('1');
-        });
-    });
-
-    describe('at', async function () {
-        it('should be get from empty data', async function () {
-            expect(await this.AddressSetMock.at(0)).to.be.equal(constants.ZERO_ADDRESS);
-            expect(await this.AddressSetMock.at(1)).to.be.equal(constants.ZERO_ADDRESS);
-        });
-
-        it('should be get from data with 1 element', async function () {
-            await this.AddressSetMock.add(wallet1);
-            expect(await this.AddressSetMock.at(0)).to.be.equal(wallet1);
-            expect(await this.AddressSetMock.at(1)).to.be.equal(constants.ZERO_ADDRESS);
-        });
-
-        it('should be get from data with several elements', async function () {
-            await this.AddressSetMock.add(wallet1);
-            await this.AddressSetMock.add(wallet2);
-            expect(await this.AddressSetMock.at(0)).to.be.equal(wallet1);
-            expect(await this.AddressSetMock.at(1)).to.be.equal(wallet2);
-        });
-    });
-
-    describe('contains', async function () {
-        it('should be not contains in empty data', async function () {
-            expect(await this.AddressSetMock.contains(wallet1)).to.be.equal(false);
-            expect(await this.AddressSetMock.contains(wallet2)).to.be.equal(false);
-            expect(await this.AddressSetMock.contains(constants.ZERO_ADDRESS)).to.be.equal(false);
-        });
-
-        it('should be contains address', async function () {
-            await this.AddressSetMock.add(wallet1);
-            expect(await this.AddressSetMock.contains(wallet1)).to.be.equal(true);
-            expect(await this.AddressSetMock.contains(wallet2)).to.be.equal(false);
-            expect(await this.AddressSetMock.contains(constants.ZERO_ADDRESS)).to.be.equal(false);
-        });
-
-        it('should be contains addresses', async function () {
-            await this.AddressSetMock.add(wallet1);
-            await this.AddressSetMock.add(wallet2);
-            expect(await this.AddressSetMock.contains(wallet1)).to.be.equal(true);
-            expect(await this.AddressSetMock.contains(wallet2)).to.be.equal(true);
-            expect(await this.AddressSetMock.contains(wallet3)).to.be.equal(false);
-            expect(await this.AddressSetMock.contains(constants.ZERO_ADDRESS)).to.be.equal(false);
-        });
-    });
-
-    describe('add', async function () {
-        it('should be add to empty data', async function () {
-            const isAdded = await this.AddressSetMock.add.call(wallet1);
-            await this.AddressSetMock.add(wallet1);
-            expect(await this.AddressSetMock.contains(wallet1)).to.be.equal(isAdded);
-        });
-
-        it('should not be add a double element without another elements in data', async function () {
-            await this.AddressSetMock.add(wallet1);
-            expect(await this.AddressSetMock.add.call(wallet1)).to.be.equal(false);
-        });
-
-        it('should be add to data with 1 element', async function () {
-            await this.AddressSetMock.add(wallet1);
-            const isAdded = await this.AddressSetMock.add.call(wallet2);
-            await this.AddressSetMock.add(wallet2);
-            expect(await this.AddressSetMock.contains(wallet2)).to.be.equal(isAdded);
-        });
-
-        it('should not be add a double element with another elements in data', async function () {
-            await this.AddressSetMock.add(wallet1);
-            await this.AddressSetMock.add(wallet2);
-            expect(await this.AddressSetMock.add.call(wallet2)).to.be.equal(false);
-        });
-    });
-
-    describe('remove', async function () {
-        it('should not be remove from empty data', async function () {
-            const isRemoved = await this.AddressSetMock.remove.call(wallet1);
-            expect(isRemoved).to.be.equal(false);
-        });
-
-        it('should be remove from data', async function () {
-            await this.AddressSetMock.add(wallet1);
-            const isRemoved = await this.AddressSetMock.remove.call(wallet1);
-            await this.AddressSetMock.remove(wallet1);
-            expect(isRemoved).to.be.equal(true);
-            expect(await this.AddressSetMock.contains(wallet1)).to.be.equal(false);
-        });
-
-        it('should not be remove element which is not in data', async function () {
-            await this.AddressSetMock.add(wallet1);
-            const isRemoved = await this.AddressSetMock.remove.call(wallet2);
-            expect(isRemoved).to.be.equal(false);
-        });
-
-        it('should be remove from data and keep the remainder', async function () {
-            await this.AddressSetMock.add(wallet1);
-            await this.AddressSetMock.add(wallet2);
-            const isRemoved = await this.AddressSetMock.remove.call(wallet1);
-            await this.AddressSetMock.remove(wallet1);
-            expect(isRemoved).to.be.equal(true);
-            expect(await this.AddressSetMock.contains(wallet1)).to.be.equal(false);
-            expect(await this.AddressSetMock.contains(wallet2)).to.be.equal(true);
-        });
-    });
-});

package/test/libraries/RevertReasonParser.js

@@ -1,45 +0,0 @@
-const { expectRevert } = require('@openzeppelin/test-helpers');
-
-const RevertReasonParserTest = artifacts.require('RevertReasonParserTest');
-
-describe('RevertReasonParser', async () => {
-    before(async function () {
-        this.RevertReasonParserTest = await RevertReasonParserTest.new();
-    });
-
-    describe('parse', async function () {
-        it('should be reverted with Invalid revert reason', async function () {
-            await expectRevert(
-                this.RevertReasonParserTest.testParseWithThrow(),
-                'Invalid revert reason',
-            );
-        });
-
-        it('should be parsed as empty Error', async function () {
-            await this.RevertReasonParserTest.testEmptyStringRevert();
-        });
-
-        it('should be parsed as Error', async function () {
-            await this.RevertReasonParserTest.testNonEmptyRevert();
-        });
-
-        it('should be parsed as Unknown', async function () {
-            await this.RevertReasonParserTest.testEmptyRevert();
-        });
-
-        it('should be parsed as Panic', async function () {
-            await this.RevertReasonParserTest.testAssertion();
-        });
-
-        it('should be parsed as Error with long string', async function () {
-            await this.RevertReasonParserTest.testLongStringRevert();
-        });
-
-        it('should be reverted in _test()', async function () {
-            await expectRevert(
-                this.RevertReasonParserTest.testWithThrow(),
-                'testFunctions without throw',
-            );
-        });
-    });
-});

package/test/libraries/StringUtil.js

@@ -1,90 +0,0 @@
-const { expect } = require('chai');
-
-const StringUtilTest = artifacts.require('StringUtilTest');
-
-describe('StringUtil', async () => {
-    const uint256TestValue = '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
-    const uint128TestValue = '0x00000000000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
-    const veryLongArray = '0xffffffffffffffafafafbcbcbcbcbdeded' + 'aa'.repeat(50);
-    const extremelyLongArray = '0x' + '0f'.repeat(1000);
-    const emptyBytes = '0x';
-    const singleByte = '0xaf';
-
-    before(async () => {
-        this.stringUtilTest = await StringUtilTest.new();
-    });
-
-    describe('Validity', async () => {
-        it('Uint 256', () => test(uint256TestValue));
-
-        it('Uint 128', () => test(uint128TestValue));
-
-        it('Very long byte array', () => testBytes(veryLongArray));
-
-        it('Extremely long byte array', () => testBytes(extremelyLongArray));
-
-        it.skip('Empty bytes. Skipped until resolved: https://github.com/ChainSafe/web3.js/issues/4512', () => testBytes(emptyBytes));
-
-        it('Single byte', () => testBytes(singleByte));
-
-        const test = async (value) => {
-            const result = await this.stringUtilTest.toHex(value, 0);
-            const naiveResult = await this.stringUtilTest.toHexNaive(value, 0);
-            expect(result.toLowerCase()).to.be.equal(value.toLowerCase());
-            expect(result.toLowerCase()).to.be.equal(naiveResult.toLowerCase());
-        };
-
-        const testBytes = async (value) => {
-            const result = await this.stringUtilTest.toHexBytes(value, 0);
-            const naiveResult = await this.stringUtilTest.toHexNaiveBytes(value, 0);
-            expect(result.toLowerCase()).to.be.equal(value.toLowerCase());
-            expect(result.toLowerCase()).to.be.equal(naiveResult.toLowerCase());
-        };
-    });
-
-    describe('Gas usage @skip-on-coverage', async () => {
-        it('Uint 256', () => testGasUint256(uint256TestValue, 917));
-
-        it('Uint 256 naive', () => testGasNaiveUint256(uint256TestValue, 14175));
-
-        it('Uint 256 as bytes', () => testGasBytes(uint256TestValue, 792));
-
-        it('Uint 256 as bytes naive', () => testGasNaiveBytes(uint256TestValue, 14050));
-
-        it('Uint 128', () => testGasUint256(uint128TestValue, 917));
-
-        it('Uint 128 naive', () => testGasNaiveUint256(uint128TestValue, 14175));
-
-        it('Very long byte array gas', () => testGasBytes(veryLongArray, 1974));
-
-        it('Very long byte array gas naive', () => testGasNaiveBytes(veryLongArray, 28972));
-
-        it('Extremely long byte array gas', () => testGasBytes(extremelyLongArray, 19131));
-
-        it('Extremely long byte array gas naive', () => testGasNaiveBytes(extremelyLongArray, 426795));
-
-        it('Empty bytes', () => testGasBytes(emptyBytes, 201));
-
-        it('Empty bytes naive', () => testGasNaiveBytes(emptyBytes, 406));
-
-        it('Single byte', () => testGasBytes(singleByte, 792));
-
-        it('Single byte naive', () => testGasNaiveBytes(singleByte, 832));
-
-        const testGasUint256 = async (value, expectedGas) => {
-            await this.stringUtilTest.toHex(value, expectedGas);
-        };
-
-        const testGasBytes = async (value, expectedGas) => {
-            await this.stringUtilTest.toHexBytes(value, expectedGas);
-        };
-
-        const testGasNaiveUint256 = async (value, expectedGas) => {
-            await this.stringUtilTest.toHexNaive(value, expectedGas);
-        };
-
-        const testGasNaiveBytes = async (value, expectedGas) => {
-            await this.stringUtilTest.toHexNaiveBytes(value, expectedGas);
-        };
-    });
-});

package/test/profileEVM.js

@@ -1,45 +0,0 @@
-const { expect } = require('chai');
-const { profileEVM, gasspectEVM } = require('../js/profileEVM.js');
-const { ether } = require('@openzeppelin/test-helpers');
-
-const TokenMock = artifacts.require('TokenMock');
-
-contract('', function ([wallet1, wallet2]) {
-    before(async function () {
-        this.USDT = await TokenMock.new('USDT', 'USDT');
-    });
-
-    beforeEach(async function () {
-        for (const addr of [wallet1, wallet2]) {
-            await this.USDT.mint(addr, ether('1000'));
-        }
-    });
-
-    describe('profileEVM', async function () {
-        it('should be counted ERC20 Transfer', async function () {
-            const receipt = await this.USDT.transfer(wallet2, ether('1'), { from: wallet1 });
-            expect(await profileEVM(receipt.tx, ['STATICCALL', 'CALL', 'SSTORE', 'SLOAD']))
-                .to.be.deep.equal([0, 0, 2, 2]);
-        });
-
-        it('should be counted ERC20 Approve', async function () {
-            const receipt = await this.USDT.approve(wallet2, ether('1'), { from: wallet1 });
-            expect(await profileEVM(receipt.tx, ['STATICCALL', 'CALL', 'SSTORE', 'SLOAD']))
-                .to.be.deep.equal([0, 0, 1, 0]);
-        });
-    });
-
-    describe('gasspectEVM', async function () {
-        it('should be counted ERC20 Transfer', async function () {
-            const receipt = await this.USDT.transfer(wallet2, ether('1'), { from: wallet1 });
-            expect(await gasspectEVM(receipt.tx))
-                .to.be.deep.equal(['0-0-SLOAD = 2100', '0-0-SSTORE = 2900', '0-0-SLOAD = 2100', '0-0-SSTORE = 2900', '0-0-LOG3 = 1756']);
-        });
-
-        it('should be counted ERC20 Approve', async function () {
-            const receipt = await this.USDT.approve(wallet2, ether('1'), { from: wallet1 });
-            expect(await gasspectEVM(receipt.tx))
-                .to.be.deep.equal(['0-0-SSTORE = 2200', '0-0-LOG3 = 1756']);
-        });
-    });
-});