Increase coverage

packages/contracts/.solcover.js

@@ -1,4 +1,9 @@
-const { accountsList: accounts } = require("./buidlerAccountsList2k.js");
+const { accountsList } = require("./buidlerAccountsList2k.js");
+// syntax for solcover network (ganache based) is different:
+// https://hardhat.org/plugins/solidity-coverage.html#configuration
+// Link in providerOptions:
+// https://github.com/trufflesuite/ganache-core#options
+const accounts = accountsList.map(a => ({ secretKey: a.privateKey, balance: '0xc097ce7bc90715b34b9f1000000000' }))
 
 module.exports = {
   providerOptions: {
@@ -7,10 +12,8 @@ module.exports = {
 
   // Improve performance by skipping statements and functions. Tool still checks lines of code and branches:
   // https://github.com/sc-forks/solidity-coverage/blob/master/docs/advanced.md
-  measureStatementCoverage: false,
-  measureFunctionCoverage: false,
-
-  testfiles: "test/LUSDTokenTest.js",
+  //measureStatementCoverage: false,
+  //measureFunctionCoverage: false,
 
   skipFiles: [
     "TestContracts/",
@@ -19,6 +22,7 @@ module.exports = {
     "Interfaces/",
     "Dependencies/Context.sol",
     "Dependencies/IERC20.sol",
+    "Dependencies/IERC2612.sol",
     "Dependencies/Math.sol",
     "Dependencies/Ownable.sol",
     "Dependencies/SafeMath.sol",

packages/contracts/contracts/TestContracts/CLVTokenTester.sol → packages/contracts/contracts/TestContracts/LUSDTokenTester.sol

@@ -42,4 +42,23 @@ contract LUSDTokenTester is LUSDToken {
         _approve(owner, spender, amount);
     }
 
+    function getChainId() external pure returns (uint256 chainID) {
+        //return _chainID(); // it’s private
+        assembly {
+            chainID := chainid()
+        }
+    }
+
+    function getDigest(address owner, address spender, uint amount, uint nonce, uint deadline) external view returns (bytes32) {
+        return keccak256(abi.encodePacked(
+                uint16(0x1901),
+                domainSeparator(),
+                keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, amount, nonce, deadline))
+            )
+        );
+    }
+
+    function recoverAddress(bytes32 digest, uint8 v, bytes32 r, bytes32 s) external pure returns (address) {
+        return ecrecover(digest, v, r, s);
+    }
 }

packages/contracts/contracts/TestContracts/LiquitySafeMath128Tester.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.6.11;
+
+import "../Dependencies/LiquitySafeMath128.sol";
+
+/* Tester contract for math functions in LiquitySafeMath128.sol library. */
+
+contract LiquitySafeMath128Tester {
+    using LiquitySafeMath128 for uint128;
+
+    function add(uint128 a, uint128 b) external pure returns (uint128) {
+        return a.add(b);
+    }
+
+    function sub(uint128 a, uint128 b) external pure returns (uint128) {
+        return a.sub(b);
+    }
+}

packages/contracts/contracts/TestContracts/NonPayable.sol

@@ -2,14 +2,23 @@
 
 pragma solidity 0.6.11;
 
+//import "../Dependencies/console.sol";
+
 
 contract NonPayable {
+    bool isPayable;
+
+    function setPayable(bool _isPayable) external {
+        isPayable = _isPayable;
+    }
+
     function forward(address _dest, bytes calldata _data) external payable {
         (bool success, bytes memory returnData) = _dest.call{ value: msg.value }(_data);
+        //console.logBytes(returnData);
         require(success, string(returnData));
     }
 
     receive() external payable {
-        revert();
+        require(isPayable);
     }
 }

packages/contracts/contracts/TestContracts/SortedTrovesTester.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.6.11;
+
+import "../Interfaces/ISortedTroves.sol";
+
+
+contract SortedTrovesTester {
+    ISortedTroves sortedTroves;
+
+    function setSortedTroves(address _sortedTrovesAddress) external {
+        sortedTroves = ISortedTroves(_sortedTrovesAddress);
+    }
+
+    function insert(address _id, uint256 _ICR, uint _price, address _prevId, address _nextId) external {
+        sortedTroves.insert(_id, _ICR, _price, _prevId, _nextId);
+    }
+
+    function remove(address _id) external {
+        sortedTroves.remove(_id);
+    }
+
+    function reInsert(address _id, uint256 _newICR, uint _price, address _prevId, address _nextId) external {
+        sortedTroves.reInsert(_id, _newICR, _price, _prevId, _nextId);
+    }
+
+    function getCurrentICR(address, uint) external pure returns (uint) {
+        return 1;
+    }
+}

packages/contracts/test/DefaultPoolTest.js

@@ -0,0 +1,29 @@
+const testHelpers = require("../utils/testHelpers.js")
+const DefaultPool = artifacts.require("./DefaultPool.sol");
+const NonPayable = artifacts.require('NonPayable.sol')
+
+const th = testHelpers.TestHelper
+const dec = th.dec
+
+contract('DefaultPool', async accounts => {
+  let defaultPool
+  let nonPayable
+
+  let [owner] = accounts
+
+  beforeEach('Deploy contracts', async () => {
+    defaultPool = await DefaultPool.new()
+    nonPayable = await NonPayable.new()
+    await defaultPool.setAddresses(owner, owner)
+  })
+
+  it('sendETH(): fails if receiver cannot receive ETH', async () => {
+    const amount = dec(1, 'ether')
+
+    await web3.eth.sendTransaction({ to: defaultPool.address, from: owner, value: amount })
+
+    await th.assertRevert(defaultPool.sendETH(nonPayable.address, amount, { from: owner }), 'DefaultPool: sending ETH failed')
+  })
+})
+
+contract('Reset chain state', async accounts => { })

packages/contracts/test/LUSDTokenTest.js

@@ -65,11 +65,14 @@ contract('LUSDToken', async accounts => {
 
   describe('Basic token functions', async () => {
     beforeEach(async () => {
-      chainId = await web3.eth.getChainId()
 
       const contracts = await deploymentHelper.deployTesterContractsBuidler()
 
       lusdTokenTester = contracts.lusdToken
+      // for some reason this doesn’t work with coverage network
+      //chainId = await web3.eth.getChainId()
+      chainId = await lusdTokenTester.getChainId()
+
       stabilityPool = contracts.stabilityPool
       troveManager = contracts.stabilityPool
       borrowerOperations = contracts.borrowerOperations
@@ -280,7 +283,21 @@ contract('LUSDToken', async accounts => {
       await assertRevert(lusdTokenTester.transfer(stabilityPool.address, 1, { from: alice }))
       await assertRevert(lusdTokenTester.transfer(borrowerOperations.address, 1, { from: alice }))
     })
-
+
+    it('decreaseAllowance(): decreases allowance by the expected amount', async () => {
+      await lusdTokenTester.approve(bob, dec(3, 18), { from: alice })
+      assert.equal((await lusdTokenTester.allowance(alice, bob)).toString(), dec(3, 18))
+      await lusdTokenTester.decreaseAllowance(bob, dec(1, 18), { from: alice })
+      assert.equal((await lusdTokenTester.allowance(alice, bob)).toString(), dec(2, 18))
+    })
+
+    it('decreaseAllowance(): fails trying to decrease more than previously allowed', async () => {
+      await lusdTokenTester.approve(bob, dec(3, 18), { from: alice })
+      assert.equal((await lusdTokenTester.allowance(alice, bob)).toString(), dec(3, 18))
+      await assertRevert(lusdTokenTester.decreaseAllowance(bob, dec(4, 18), { from: alice }), 'ERC20: decreased allowance below zero')
+      assert.equal((await lusdTokenTester.allowance(alice, bob)).toString(), dec(3, 18))
+    })
+
     // EIP2612 tests
 
     it('Initializes PERMIT_TYPEHASH correctly', async () => {
@@ -296,32 +313,40 @@ contract('LUSDToken', async accounts => {
       assert.equal(toBN(await lusdTokenTester.nonces(alice)).toString(), '0');
     });
 
-    it('permits and emits an Approval event (replay protected)', async () => {
-      // Create the approval tx data
-      const approve = {
-        owner: alice,
-        spender: bob,
-        value: 1,
-      }
-
-      const deadline = 100000000000000
+    // Create the approval tx data
+    const approve = {
+      owner: alice,
+      spender: bob,
+      value: 1,
+    }
+
+    const buildPermitTx = async (deadline) => {
       const nonce = await lusdTokenTester.nonces(approve.owner)
-
+      
       // Get the EIP712 digest
       const digest = getPermitDigest(
         tokenName, lusdTokenTester.address, 
         chainId, tokenVersion, 
         approve.owner, approve.spender,
         approve.value, nonce, deadline
       )
-
+      
       const { v, r, s } = sign(digest, alicePrivateKey)
 
-      // Approve it
-      const receipt = await lusdTokenTester.permit(
+      const tx = lusdTokenTester.permit(
         approve.owner, approve.spender, approve.value, 
         deadline, v, hexlify(r), hexlify(s)
       )
+
+      return { v, r, s, tx }
+    }
+
+    it('permits and emits an Approval event (replay protected)', async () => {
+      const deadline = 100000000000000
+
+      // Approve it
+      const { v, r, s, tx } = await buildPermitTx(deadline)
+      const receipt = await tx
       const event = receipt.logs[0]
 
       // Check that approval was successful
@@ -338,6 +363,49 @@ contract('LUSDToken', async accounts => {
       assertRevert(lusdTokenTester.permit('0x0000000000000000000000000000000000000000', 
         approve.spender, approve.value, deadline, '0x99', r, s), 'LUSD: Recovered address from the sig is not the owner')
     })
+
+    it('permits and emits an Approval event (replay protected), with infinite deadline', async () => {
+      const deadline = 0
+
+      // Approve it
+      const { v, r, s, tx } = await buildPermitTx(deadline)
+      const receipt = await tx
+      const event = receipt.logs[0]
+
+      // Check that approval was successful
+      assert.equal(event.event, 'Approval')
+      assert.equal(await lusdTokenTester.nonces(approve.owner), 1)
+      assert.equal(await lusdTokenTester.allowance(approve.owner, approve.spender), approve.value)
+
+      // Check that we can not use re-use the same signature, since the user's nonce has been incremented (replay protection)
+      assertRevert(lusdTokenTester.permit(
+        approve.owner, approve.spender, approve.value, 
+        deadline, v, r, s), 'LUSD: Recovered address from the sig is not the owner')
+
+      // Check that the zero address fails
+      assertRevert(lusdTokenTester.permit('0x0000000000000000000000000000000000000000', 
+        approve.spender, approve.value, deadline, '0x99', r, s), 'LUSD: Recovered address from the sig is not the owner')
+    })
+
+    it('permits(): fails with expired deadline', async () => {
+      const deadline = 1
+
+      const { v, r, s, tx } = await buildPermitTx(deadline)
+      await assertRevert(tx, 'LUSD: Signature has expired')
+    })
+
+    it('permits(): fails with the wrong signature', async () => {
+      const deadline = 100000000000000
+
+      const { v, r, s } = await buildPermitTx(deadline)
+
+      const tx = lusdTokenTester.permit(
+        carol, approve.spender, approve.value,
+        deadline, v, hexlify(r), hexlify(s)
+      )
+
+      await assertRevert(tx, 'LUSD: Recovered address from the sig is not the owner')
+    })
   })
 })
 

packages/contracts/test/LiquitySafeMath128Test.js

@@ -0,0 +1,21 @@
+const testHelpers = require("../utils/testHelpers.js")
+const th = testHelpers.TestHelper
+
+const LiquitySafeMath128Tester = artifacts.require("LiquitySafeMath128Tester")
+
+contract('LiquitySafeMath128Tester', async accounts => {
+  let mathTester
+
+  beforeEach(async () => {
+    mathTester = await LiquitySafeMath128Tester.new()
+  })
+
+  it('add(): reverts if overflows', async () => {
+    const MAX_UINT_128 = th.toBN(2).pow(th.toBN(128)).sub(th.toBN(1))
+    await th.assertRevert(mathTester.add(MAX_UINT_128, 1), 'LiquitySafeMath128: addition overflow')
+  })
+
+  it('sub(): reverts if underflows', async () => {
+    await th.assertRevert(mathTester.sub(1, 2), 'LiquitySafeMath128: subtraction overflow')
+  })
+})