@1inch/solidity-utils 1.2.2 → 1.2.7

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

package/test/utils.js

@@ -1,166 +0,0 @@
-const { expect } = require('chai');
-const { time, ether, BN } = require('@openzeppelin/test-helpers');
-const {
-    timeIncreaseTo,
-    fixSignature,
-    signMessage,
-    trackReceivedTokenAndTx,
-    trackReceivedToken,
-    countInstructions,
-} = require('../js/utils.js');
-
-const TokenMock = artifacts.require('TokenMock');
-
-describe('timeIncreaseTo', async function () {
-    const precision = 2;
-
-    async function shouldIncrease (secs) {
-        const timeBefore = await time.latest();
-        await timeIncreaseTo(timeBefore.addn(secs));
-        const timeAfter = await time.latest();
-
-        expect(timeAfter).to.be.bignumber.gt(timeBefore);
-        expect(timeAfter.sub(timeBefore)).to.be.bignumber.lte(new BN(secs).addn(precision));
-        expect(timeAfter.sub(timeBefore)).to.be.bignumber.gte(new BN(secs));
-    }
-
-    it('should be increased on 1000 sec', async function () {
-        await shouldIncrease(1000);
-    });
-
-    it('should be increased on 2000 sec', async function () {
-        await shouldIncrease(2000);
-    });
-
-    it('should be increased on 1000000 sec', async function () {
-        await shouldIncrease(1000000);
-    });
-
-    it('should be thrown with increase time to a moment in the past', async function () {
-        try {
-            await shouldIncrease(-1000);
-        } catch (e) {
-            expect(e.message).contains('Cannot increase current time');
-            expect(e.message).contains('to a moment in the past');
-            return;
-        }
-        expect(true).equal(false);
-    });
-});
-
-describe('fixSignature', async function () {
-    it('should not be fixed geth sign', async function () {
-        const signature = '0xb453386b73ba5608314e9b4c7890a4bd12cc24c2c7bdf5f87778960ff85c56a8520dabdbea357fc561120dd2625bd8a904f35bdb4b153cf706b6ff25bb0d898d1c';
-        expect(signature).equal(fixSignature(signature));
-    });
-
-    it('should be fixed ganache sign', async function () {
-        const signature = '0x511fafdf71306ff89a063a76b52656c18e9a7d80d19e564c90f0126f732696bb673cde46003aad0ccb6dab2ca91ae38b82170824b0725883875194b273f709b901';
-        const v = parseInt(signature.slice(130, 132), 16) + 27;
-        const vHex = v.toString(16);
-        expect(signature.slice(0, 130) + vHex).equal(fixSignature(signature));
-    });
-});
-
-contract('', function ([wallet1, wallet2]) {
-    before(async function () {
-        this.USDT = await TokenMock.new('USDT', 'USDT');
-        this.USDC = await TokenMock.new('USDC', 'USDC');
-    });
-
-    beforeEach(async function () {
-        for (const addr of [wallet1, wallet2]) {
-            for (const token of [this.USDT, this.USDC]) {
-                await token.mint(addr, ether('1000'));
-            }
-        }
-    });
-
-    describe('signMessage', async function () {
-        it('should be signed test1', async function () {
-            expect(await web3.eth.sign('0x', wallet1)).equal(await signMessage(wallet1));
-        });
-
-        it('should be signed test2', async function () {
-            const message = web3.utils.randomHex(32);
-            expect(await web3.eth.sign(message, wallet1)).equal(await signMessage(wallet1, message));
-        });
-
-        it('should be signed test3', async function () {
-            const message = web3.utils.toHex('Test message'); ;
-            expect(await web3.eth.sign(message, wallet1)).equal(await signMessage(wallet1, message));
-        });
-    });
-
-    describe('trackReceivedTokenAndTx', async function () {
-        it('should be tracked ERC20 Transfer', async function () {
-            const [received, tx] = await trackReceivedTokenAndTx(
-                this.USDT,
-                wallet2,
-                () => this.USDT.transfer(wallet2, ether('1'), { from: wallet1 }),
-            );
-            expect(received).to.be.bignumber.equal(ether('1'));
-            expect(tx.tx.length).equal(66);
-            expect(tx.receipt.from).equal(wallet1.toLowerCase());
-            expect(tx.receipt.to).equal(this.USDT.address.toLowerCase());
-            expect(tx.logs.length).equal(1);
-            expect(tx.logs[0].event).equal('Transfer');
-        });
-
-        it('should be tracked ERC20 Approve', async function () {
-            const [received, tx] = await trackReceivedTokenAndTx(
-                this.USDT,
-                wallet2,
-                () => this.USDT.approve(wallet2, ether('1'), { from: wallet1 }),
-            );
-            expect(received).to.be.bignumber.equal('0');
-            expect(tx.tx.length).equal(66);
-            expect(tx.receipt.from).equal(wallet1.toLowerCase());
-            expect(tx.receipt.to).equal(this.USDT.address.toLowerCase());
-            expect(tx.logs.length).equal(1);
-            expect(tx.logs[0].event).equal('Approval');
-        });
-    });
-
-    describe('trackReceivedToken', async function () {
-        it('should be tracked ERC20 Transfer', async function () {
-            const received = await trackReceivedToken(
-                this.USDT,
-                wallet2,
-                () => this.USDT.transfer(wallet2, ether('1'), { from: wallet1 }),
-            );
-            expect(received).to.be.bignumber.equal(ether('1'));
-        });
-
-        it('should be tracked ERC20 Approve', async function () {
-            const received = await trackReceivedToken(
-                this.USDT,
-                wallet2,
-                () => this.USDT.approve(wallet2, ether('1'), { from: wallet1 }),
-            );
-            expect(received).to.be.bignumber.equal('0');
-        });
-    });
-
-    describe('countInstructions', async function () {
-        it('should be counted ERC20 Transfer', async function () {
-            const [, tx] = await trackReceivedTokenAndTx(
-                this.USDT,
-                wallet2,
-                () => this.USDT.transfer(wallet2, ether('1'), { from: wallet1 }),
-            );
-            expect(await countInstructions(tx.receipt.transactionHash, ['STATICCALL', 'CALL', 'SSTORE', 'SLOAD']))
-                .to.be.deep.equal([0, 0, 2, 2]);
-        });
-
-        it('should be counted ERC20 Approve', async function () {
-            const [, tx] = await trackReceivedTokenAndTx(
-                this.USDT,
-                wallet2,
-                () => this.USDT.approve(wallet2, ether('1'), { from: wallet1 }),
-            );
-            expect(await countInstructions(tx.receipt.transactionHash, ['STATICCALL', 'CALL', 'SSTORE', 'SLOAD']))
-                .to.be.deep.equal([0, 0, 1, 0]);
-        });
-    });
-});