@1inch/solidity-utils 1.2.2 → 1.2.7

package/contracts/tests/RevertReasonParserTest.sol

@@ -1,85 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.0;
-pragma abicoder v1;
-
-import "../libraries/RevertReasonParser.sol";
-
-contract RevertReasonParserTest {
-    function emptyRevert() external pure  {
-        revert();  // solhint-disable-line reason-string
-    }
-
-    function emptyStringRevert() external pure  {
-        revert("");
-    }
-
-    function nonEmptyRevert() external pure {
-        revert("reason");
-    }
-
-    function assertion() external pure {
-        assert(false);
-    }
-
-    function longStringRevert() external pure {
-        // solhint-disable-next-line reason-string
-        revert("Very long text to test for reverts that return string of more than 32 bytes length");
-    }
-
-    function withoutAssertion() external pure {
-        assert(true);
-    }
-
-    function testEmptyRevert() external view {
-        _test(this.emptyRevert, "Unknown(0x)");
-    }
-
-    function testEmptyStringRevert() external view {
-        _test(this.emptyStringRevert, "Error()");
-    }
-
-    function testNonEmptyRevert() external view {
-        _test(this.nonEmptyRevert, "Error(reason)");
-    }
-
-    function testAssertion() external view {
-        _test(this.assertion, "Panic(0x0000000000000000000000000000000000000000000000000000000000000001)");
-    }
-
-    function testLongStringRevert() external view {
-        _test(this.longStringRevert, "Error(Very long text to test for reverts that return string of more than 32 bytes length)");
-    }
-
-    function testParseWithThrow() external view {
-        try this.nonEmptyRevert() { // solhint-disable-line no-empty-blocks
-        } catch (bytes memory reason) {
-            bytes32 invalidReasonPart1;
-            bytes32 invalidReasonPart2;
-            bytes32 invalidReasonPart3;
-            assembly {  // solhint-disable-line no-inline-assembly
-                invalidReasonPart1 := mload(add(reason, 0x20))
-                invalidReasonPart2 := mload(add(reason, 0x40))
-                invalidReasonPart3 := mload(add(reason, 0x40))
-            }
-            bytes memory invalidReason = abi.encodePacked(invalidReasonPart1, invalidReasonPart2, invalidReasonPart3);
-            RevertReasonParser.parse(invalidReason, "");
-        }
-    }
-
-    function testWithThrow() external view {
-        _test(this.withoutAssertion, "Error(reason)");
-    }
-
-    function _test(function() external pure testFunction, string memory expectedReason) private pure {
-        try testFunction() {
-            revert("testFunctions without throw");
-        } catch (bytes memory reason) {
-            string memory parsedReason = RevertReasonParser.parse(reason, "");
-            require(
-                keccak256(abi.encodePacked(expectedReason)) == keccak256(abi.encodePacked(parsedReason)),
-                string(abi.encodePacked("Expected { ", expectedReason, " }, but got { ", parsedReason, " }"))
-            );
-        }
-    }
-}

package/contracts/tests/StringUtilTest.sol

@@ -1,26 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.0;
-pragma abicoder v1;
-
-import "../libraries/StringUtil.sol";
-import "../mocks/libraries/StringUtilNaive.sol";
-import "../GasChecker.sol";
-
-contract StringUtilTest is GasChecker {
-    function toHex(uint256 value, uint256 expectedGasCost) external view checkGasCost(expectedGasCost) returns (string memory) {
-        return StringUtil.toHex(value);
-    }
-
-    function toHexBytes(bytes memory data, uint256 expectedGasCost) external view checkGasCost(expectedGasCost) returns (string memory) {
-        return StringUtil.toHex(data);
-    }
-
-    function toHexNaive(uint256 value, uint256 expectedGasCost) external view checkGasCost(expectedGasCost) returns (string memory) {
-        return StringUtilNaive.toHex(value);
-    }
-
-    function toHexNaiveBytes(bytes memory data, uint256 expectedGasCost) external view checkGasCost(expectedGasCost) returns (string memory) {
-        return StringUtilNaive.toHex(data);
-    }
-}

package/hardhat.config.js

@@ -1,33 +0,0 @@
-require('@nomiclabs/hardhat-etherscan');
-require('@nomiclabs/hardhat-truffle5');
-require('dotenv').config();
-require('hardhat-deploy');
-require('hardhat-gas-reporter');
-require('solidity-coverage');
-
-const networks = require('./hardhat.networks');
-
-module.exports = {
-    etherscan: {
-        apiKey: process.env.ETHERSCAN_KEY,
-    },
-    solidity: {
-        version: '0.8.9',
-        settings: {
-            optimizer: {
-                enabled: true,
-                runs: 1000000,
-            },
-        },
-    },
-    networks,
-    namedAccounts: {
-        deployer: {
-            default: 0,
-        },
-    },
-    gasReporter: {
-        enable: true,
-        currency: 'USD',
-    },
-};

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',
-            );
-        });
-    });
-});