@bgd-labs/aave-address-book 1.1.1

package/lib/forge-std/src/test/StdCheats.t.sol

@@ -0,0 +1,282 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.7.0 <0.9.0;
+
+import "../Test.sol";
+import "../StdJson.sol";
+
+contract StdCheatsTest is Test {
+    Bar test;
+
+    using stdJson for string;
+
+    function setUp() public {
+        test = new Bar();
+    }
+
+    function testSkip() public {
+        vm.warp(100);
+        skip(25);
+        assertEq(block.timestamp, 125);
+    }
+
+    function testRewind() public {
+        vm.warp(100);
+        rewind(25);
+        assertEq(block.timestamp, 75);
+    }
+
+    function testHoax() public {
+        hoax(address(1337));
+        test.bar{value: 100}(address(1337));
+    }
+
+    function testHoaxOrigin() public {
+        hoax(address(1337), address(1337));
+        test.origin{value: 100}(address(1337));
+    }
+
+    function testHoaxDifferentAddresses() public {
+        hoax(address(1337), address(7331));
+        test.origin{value: 100}(address(1337), address(7331));
+    }
+
+    function testStartHoax() public {
+        startHoax(address(1337));
+        test.bar{value: 100}(address(1337));
+        test.bar{value: 100}(address(1337));
+        vm.stopPrank();
+        test.bar(address(this));
+    }
+
+    function testStartHoaxOrigin() public {
+        startHoax(address(1337), address(1337));
+        test.origin{value: 100}(address(1337));
+        test.origin{value: 100}(address(1337));
+        vm.stopPrank();
+        test.bar(address(this));
+    }
+
+    function testChangePrank() public {
+        vm.startPrank(address(1337));
+        test.bar(address(1337));
+        changePrank(address(0xdead));
+        test.bar(address(0xdead));
+        changePrank(address(1337));
+        test.bar(address(1337));
+        vm.stopPrank();
+    }
+
+    function testMakeAddrEquivalence() public {
+        (address addr, ) = makeAddrAndKey("1337");
+        assertEq(makeAddr("1337"), addr);
+    }
+
+    function testMakeAddrSigning() public {
+        (address addr, uint256 key) = makeAddrAndKey("1337");
+        bytes32 hash = keccak256("some_message");
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(key, hash);
+        assertEq(ecrecover(hash, v, r, s), addr);
+    }
+
+    function testDeal() public {
+        deal(address(this), 1 ether);
+        assertEq(address(this).balance, 1 ether);
+    }
+
+    function testDealToken() public {
+        Bar barToken = new Bar();
+        address bar = address(barToken);
+        deal(bar, address(this), 10000e18);
+        assertEq(barToken.balanceOf(address(this)), 10000e18);
+    }
+
+    function testDealTokenAdjustTS() public {
+        Bar barToken = new Bar();
+        address bar = address(barToken);
+        deal(bar, address(this), 10000e18, true);
+        assertEq(barToken.balanceOf(address(this)), 10000e18);
+        assertEq(barToken.totalSupply(), 20000e18);
+        deal(bar, address(this), 0, true);
+        assertEq(barToken.balanceOf(address(this)), 0);
+        assertEq(barToken.totalSupply(), 10000e18);
+    }
+
+    function testBound() public {
+        assertEq(bound(5, 0, 4), 0);
+        assertEq(bound(0, 69, 69), 69);
+        assertEq(bound(0, 68, 69), 68);
+        assertEq(bound(10, 150, 190), 160);
+        assertEq(bound(300, 2800, 3200), 3100);
+        assertEq(bound(9999, 1337, 6666), 6006);
+    }
+
+    function testCannotBoundMaxLessThanMin() public {
+        vm.expectRevert(bytes("Test bound(uint256,uint256,uint256): Max is less than min."));
+        bound(5, 100, 10);
+    }
+
+    function testBound(
+        uint256 num,
+        uint256 min,
+        uint256 max
+    ) public {
+        if (min > max) (min, max) = (max, min);
+
+        uint256 bounded = bound(num, min, max);
+
+        assertGe(bounded, min);
+        assertLe(bounded, max);
+    }
+
+    function testBoundUint256Max() public {
+        assertEq(bound(0, type(uint256).max - 1, type(uint256).max), type(uint256).max - 1);
+        assertEq(bound(1, type(uint256).max - 1, type(uint256).max), type(uint256).max);
+    }
+
+    function testCannotBoundMaxLessThanMin(
+        uint256 num,
+        uint256 min,
+        uint256 max
+    ) public {
+        vm.assume(min > max);
+        vm.expectRevert(bytes("Test bound(uint256,uint256,uint256): Max is less than min."));
+        bound(num, min, max);
+    }
+
+    function testDeployCode() public {
+        address deployed = deployCode("StdCheats.t.sol:StdCheatsTest", bytes(""));
+        assertEq(string(getCode(deployed)), string(getCode(address(this))));
+    }
+
+    function testDeployCodeNoArgs() public {
+        address deployed = deployCode("StdCheats.t.sol:StdCheatsTest");
+        assertEq(string(getCode(deployed)), string(getCode(address(this))));
+    }
+
+    // We need that payable constructor in order to send ETH on construction
+    constructor() payable {}
+
+    function testDeployCodeVal() public {
+        address deployed = deployCode("StdCheats.t.sol:StdCheatsTest", bytes(""), 1 ether);
+        assertEq(string(getCode(deployed)), string(getCode(address(this))));
+	assertEq(deployed.balance, 1 ether);
+    }
+
+    function testDeployCodeValNoArgs() public {
+        address deployed = deployCode("StdCheats.t.sol:StdCheatsTest", 1 ether);
+        assertEq(string(getCode(deployed)), string(getCode(address(this))));
+	assertEq(deployed.balance, 1 ether);
+    }
+
+    // We need this so we can call "this.deployCode" rather than "deployCode" directly
+    function deployCodeHelper(string memory what) external {
+        deployCode(what);
+    }
+
+    function testDeployCodeFail() public {
+        vm.expectRevert(bytes("Test deployCode(string): Deployment failed."));
+        this.deployCodeHelper("StdCheats.t.sol:RevertingContract");
+    }
+
+    function getCode(address who) internal view returns (bytes memory o_code) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            // retrieve the size of the code, this needs assembly
+            let size := extcodesize(who)
+            // allocate output byte array - this could also be done without assembly
+            // by using o_code = new bytes(size)
+            o_code := mload(0x40)
+            // new "memory end" including padding
+            mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f))))
+            // store length in memory
+            mstore(o_code, size)
+            // actually retrieve the code, this needs assembly
+            extcodecopy(who, add(o_code, 0x20), 0, size)
+        }
+    }
+
+    function testBytesToUint() public {
+        assertEq(3, bytesToUint(hex'03'));
+        assertEq(2, bytesToUint(hex'02'));
+        assertEq(255, bytesToUint(hex'ff'));
+        assertEq(29625, bytesToUint(hex'73b9'));
+    }
+
+    function testParseJsonTxDetail() public {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/src/test/fixtures/broadcast.log.json");
+        string memory json = vm.readFile(path);
+        bytes memory transactionDetails = json.parseRaw(".transactions[0].tx");
+        RawTx1559Detail memory rawTxDetail = abi.decode(transactionDetails, (RawTx1559Detail));
+        Tx1559Detail memory txDetail = rawToConvertedEIP1559Detail(rawTxDetail);
+        assertEq(txDetail.from, 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266);
+        assertEq(txDetail.to, 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512);
+        assertEq(txDetail.data, hex'23e99187000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000013370000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000004');
+        assertEq(txDetail.nonce, 3);
+        assertEq(txDetail.txType, 2);
+        assertEq(txDetail.gas, 29625);
+        assertEq(txDetail.value, 0);
+    }
+
+    function testReadEIP1559Transaction() public {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/src/test/fixtures/broadcast.log.json");
+        uint256 index = 0;
+        Tx1559 memory transaction = readTx1559(path, index);
+    }
+
+    function testReadEIP1559Transactions() public {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/src/test/fixtures/broadcast.log.json");
+        Tx1559[] memory transactions = readTx1559s(path);
+    }
+
+    function testReadReceipt() public {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/src/test/fixtures/broadcast.log.json");
+        uint index = 5;
+        Receipt memory receipt = readReceipt(path, index);
+        assertEq(receipt.logsBloom,
+                 hex"00000000000800000000000000000010000000000000000000000000000180000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100");
+    }
+
+    function testReadReceipts() public {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/src/test/fixtures/broadcast.log.json");
+        Receipt[] memory receipts = readReceipts(path);
+    }
+
+}
+
+contract Bar {
+    constructor() {
+        /// `DEAL` STDCHEAT
+        totalSupply = 10000e18;
+        balanceOf[address(this)] = totalSupply;
+    }
+
+    /// `HOAX` STDCHEATS
+    function bar(address expectedSender) public payable {
+        require(msg.sender == expectedSender, "!prank");
+    }
+    function origin(address expectedSender) public payable {
+        require(msg.sender == expectedSender, "!prank");
+        require(tx.origin == expectedSender, "!prank");
+    }
+    function origin(address expectedSender, address expectedOrigin) public payable {
+        require(msg.sender == expectedSender, "!prank");
+        require(tx.origin == expectedOrigin, "!prank");
+    }
+
+    /// `DEAL` STDCHEAT
+    mapping (address => uint256) public balanceOf;
+    uint256 public totalSupply;
+}
+
+contract RevertingContract {
+    constructor() {
+        revert();
+    }
+}
+

package/lib/forge-std/src/test/StdError.t.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.10 <0.9.0;
+
+import "../Test.sol";
+
+contract StdErrorsTest is Test {
+    ErrorsTest test;
+
+    function setUp() public {
+        test = new ErrorsTest();
+    }
+
+    function testExpectAssertion() public {
+        vm.expectRevert(stdError.assertionError);
+        test.assertionError();
+    }
+
+    function testExpectArithmetic() public {
+        vm.expectRevert(stdError.arithmeticError);
+        test.arithmeticError(10);
+    }
+
+    function testExpectDiv() public {
+        vm.expectRevert(stdError.divisionError);
+        test.divError(0);
+    }
+
+    function testExpectMod() public {
+        vm.expectRevert(stdError.divisionError);
+        test.modError(0);
+    }
+
+    function testExpectEnum() public {
+        vm.expectRevert(stdError.enumConversionError);
+        test.enumConversion(1);
+    }
+
+    function testExpectEncodeStg() public {
+        vm.expectRevert(stdError.encodeStorageError);
+        test.encodeStgError();
+    }
+
+    function testExpectPop() public {
+        vm.expectRevert(stdError.popError);
+        test.pop();
+    }
+
+    function testExpectOOB() public {
+        vm.expectRevert(stdError.indexOOBError);
+        test.indexOOBError(1);
+    }
+
+    function testExpectMem() public {
+        vm.expectRevert(stdError.memOverflowError);
+        test.mem();
+    }
+
+    function testExpectIntern() public {
+        vm.expectRevert(stdError.zeroVarError);
+        test.intern();
+    }
+
+    function testExpectLowLvl() public {
+        vm.expectRevert(stdError.lowLevelError);
+        test.someArr(0);
+    }
+}
+
+contract ErrorsTest {
+    enum T {
+        T1
+    }
+
+    uint256[] public someArr;
+    bytes someBytes;
+
+    function assertionError() public pure {
+        assert(false);
+    }
+
+    function arithmeticError(uint256 a) public pure {
+        a -= 100;
+    }
+
+    function divError(uint256 a) public pure {
+        100 / a;
+    }
+
+    function modError(uint256 a) public pure {
+        100 % a;
+    }
+
+    function enumConversion(uint256 a) public pure {
+        T(a);
+    }
+
+    function encodeStgError() public {
+        /// @solidity memory-safe-assembly
+        assembly {
+            sstore(someBytes.slot, 1)
+        }
+        keccak256(someBytes);
+    }
+
+    function pop() public {
+        someArr.pop();
+    }
+
+    function indexOOBError(uint256 a) public pure {
+        uint256[] memory t = new uint256[](0);
+        t[a];
+    }
+
+    function mem() public pure {
+        uint256 l = 2**256 / 32;
+        new uint256[](l);
+    }
+
+    function intern() public returns (uint256) {
+        function(uint256) internal returns (uint256) x;
+        x(2);
+        return 7;
+    }
+}

package/lib/forge-std/src/test/StdMath.t.sol

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0 <0.9.0;
+
+import "../Test.sol";
+
+contract StdMathTest is Test
+{
+    function testGetAbs() external {
+        assertEq(stdMath.abs(-50),      50);
+        assertEq(stdMath.abs(50),       50);
+        assertEq(stdMath.abs(-1337),    1337);
+        assertEq(stdMath.abs(0),        0);
+
+        assertEq(stdMath.abs(type(int256).min), (type(uint256).max >> 1) + 1);
+        assertEq(stdMath.abs(type(int256).max), (type(uint256).max >> 1));
+    }
+
+    function testGetAbs_Fuzz(int256 a) external {
+        uint256 manualAbs = getAbs(a);
+
+        uint256 abs = stdMath.abs(a);
+
+        assertEq(abs, manualAbs);
+    }
+
+    function testGetDelta_Uint() external {
+        assertEq(stdMath.delta(uint256(0),          uint256(0)),        0);
+        assertEq(stdMath.delta(uint256(0),          uint256(1337)),     1337);
+        assertEq(stdMath.delta(uint256(0),          type(uint64).max),  type(uint64).max);
+        assertEq(stdMath.delta(uint256(0),          type(uint128).max), type(uint128).max);
+        assertEq(stdMath.delta(uint256(0),          type(uint256).max), type(uint256).max);
+
+        assertEq(stdMath.delta(0,                   uint256(0)),        0);
+        assertEq(stdMath.delta(1337,                uint256(0)),        1337);
+        assertEq(stdMath.delta(type(uint64).max,    uint256(0)),        type(uint64).max);
+        assertEq(stdMath.delta(type(uint128).max,   uint256(0)),        type(uint128).max);
+        assertEq(stdMath.delta(type(uint256).max,   uint256(0)),        type(uint256).max);
+
+        assertEq(stdMath.delta(1337,                uint256(1337)),     0);
+        assertEq(stdMath.delta(type(uint256).max,   type(uint256).max), 0);
+        assertEq(stdMath.delta(5000,                uint256(1250)),     3750);
+    }
+
+    function testGetDelta_Uint_Fuzz(uint256 a, uint256 b) external {
+        uint256 manualDelta;
+        if (a > b) {
+            manualDelta = a - b;
+        } else {
+            manualDelta = b - a;
+        }
+
+        uint256 delta = stdMath.delta(a, b);
+
+        assertEq(delta, manualDelta);
+    }
+
+    function testGetDelta_Int() external {
+        assertEq(stdMath.delta(int256(0),           int256(0)),         0);
+        assertEq(stdMath.delta(int256(0),           int256(1337)),      1337);
+        assertEq(stdMath.delta(int256(0),           type(int64).max),   type(uint64).max >> 1);
+        assertEq(stdMath.delta(int256(0),           type(int128).max),  type(uint128).max >> 1);
+        assertEq(stdMath.delta(int256(0),           type(int256).max),  type(uint256).max >> 1);
+
+        assertEq(stdMath.delta(0,                   int256(0)),         0);
+        assertEq(stdMath.delta(1337,                int256(0)),         1337);
+        assertEq(stdMath.delta(type(int64).max,     int256(0)),         type(uint64).max >> 1);
+        assertEq(stdMath.delta(type(int128).max,    int256(0)),         type(uint128).max >> 1);
+        assertEq(stdMath.delta(type(int256).max,    int256(0)),         type(uint256).max >> 1);
+
+        assertEq(stdMath.delta(-0,                  int256(0)),         0);
+        assertEq(stdMath.delta(-1337,               int256(0)),         1337);
+        assertEq(stdMath.delta(type(int64).min,     int256(0)),         (type(uint64).max >> 1) + 1);
+        assertEq(stdMath.delta(type(int128).min,    int256(0)),         (type(uint128).max >> 1) + 1);
+        assertEq(stdMath.delta(type(int256).min,    int256(0)),         (type(uint256).max >> 1) + 1);
+
+        assertEq(stdMath.delta(int256(0),           -0),                0);
+        assertEq(stdMath.delta(int256(0),           -1337),             1337);
+        assertEq(stdMath.delta(int256(0),           type(int64).min),   (type(uint64).max >> 1) + 1);
+        assertEq(stdMath.delta(int256(0),           type(int128).min),  (type(uint128).max >> 1) + 1);
+        assertEq(stdMath.delta(int256(0),           type(int256).min),  (type(uint256).max >> 1) + 1);
+
+        assertEq(stdMath.delta(1337,                int256(1337)),      0);
+        assertEq(stdMath.delta(type(int256).max,    type(int256).max),  0);
+        assertEq(stdMath.delta(type(int256).min,    type(int256).min),  0);
+        assertEq(stdMath.delta(type(int256).min,    type(int256).max),  type(uint256).max);
+        assertEq(stdMath.delta(5000,                int256(1250)),      3750);
+    }
+
+    function testGetDelta_Int_Fuzz(int256 a, int256 b) external {
+        uint256 absA = getAbs(a);
+        uint256 absB = getAbs(b);
+        uint256 absDelta = absA > absB
+            ? absA - absB
+            : absB - absA;
+
+        uint256 manualDelta;
+        if ((a >= 0 && b >= 0) || (a < 0 && b < 0)) {
+            manualDelta = absDelta;
+        }
+        // (a < 0 && b >= 0) || (a >= 0 && b < 0)
+        else {
+            manualDelta = absA + absB;
+        }
+
+        uint256 delta = stdMath.delta(a, b);
+
+        assertEq(delta, manualDelta);
+    }
+
+    function testGetPercentDelta_Uint() external {
+        assertEq(stdMath.percentDelta(uint256(0),           uint256(1337)),     1e18);
+        assertEq(stdMath.percentDelta(uint256(0),           type(uint64).max),  1e18);
+        assertEq(stdMath.percentDelta(uint256(0),           type(uint128).max), 1e18);
+        assertEq(stdMath.percentDelta(uint256(0),           type(uint192).max), 1e18);
+
+        assertEq(stdMath.percentDelta(1337,                 uint256(1337)),     0);
+        assertEq(stdMath.percentDelta(type(uint192).max,    type(uint192).max), 0);
+        assertEq(stdMath.percentDelta(0,                    uint256(2500)),     1e18);
+        assertEq(stdMath.percentDelta(2500,                 uint256(2500)),     0);
+        assertEq(stdMath.percentDelta(5000,                 uint256(2500)),     1e18);
+        assertEq(stdMath.percentDelta(7500,                 uint256(2500)),     2e18);
+
+        vm.expectRevert(stdError.divisionError);
+        stdMath.percentDelta(uint256(1), 0);
+    }
+
+    function testGetPercentDelta_Uint_Fuzz(uint192 a, uint192 b) external {
+        vm.assume(b != 0);
+        uint256 manualDelta;
+        if (a > b) {
+            manualDelta = a - b;
+        } else {
+            manualDelta = b - a;
+        }
+
+        uint256 manualPercentDelta = manualDelta * 1e18 / b;
+        uint256 percentDelta = stdMath.percentDelta(a, b);
+
+        assertEq(percentDelta, manualPercentDelta);
+    }
+
+    function testGetPercentDelta_Int() external {
+        assertEq(stdMath.percentDelta(int256(0),        int256(1337)),      1e18);
+        assertEq(stdMath.percentDelta(int256(0),        -1337),             1e18);
+        assertEq(stdMath.percentDelta(int256(0),        type(int64).min),   1e18);
+        assertEq(stdMath.percentDelta(int256(0),        type(int128).min),  1e18);
+        assertEq(stdMath.percentDelta(int256(0),        type(int192).min),  1e18);
+        assertEq(stdMath.percentDelta(int256(0),        type(int64).max),   1e18);
+        assertEq(stdMath.percentDelta(int256(0),        type(int128).max),  1e18);
+        assertEq(stdMath.percentDelta(int256(0),        type(int192).max),  1e18);
+
+        assertEq(stdMath.percentDelta(1337,             int256(1337)),      0);
+        assertEq(stdMath.percentDelta(type(int192).max, type(int192).max),  0);
+        assertEq(stdMath.percentDelta(type(int192).min, type(int192).min),  0);
+
+        assertEq(stdMath.percentDelta(type(int192).min, type(int192).max),  2e18); // rounds the 1 wei diff down
+        assertEq(stdMath.percentDelta(type(int192).max, type(int192).min),  2e18 - 1); // rounds the 1 wei diff down
+        assertEq(stdMath.percentDelta(0,                int256(2500)),      1e18);
+        assertEq(stdMath.percentDelta(2500,             int256(2500)),      0);
+        assertEq(stdMath.percentDelta(5000,             int256(2500)),      1e18);
+        assertEq(stdMath.percentDelta(7500,             int256(2500)),      2e18);
+
+        vm.expectRevert(stdError.divisionError);
+        stdMath.percentDelta(int256(1), 0);
+    }
+
+    function testGetPercentDelta_Int_Fuzz(int192 a, int192 b) external {
+        vm.assume(b != 0);
+        uint256 absA = getAbs(a);
+        uint256 absB = getAbs(b);
+        uint256 absDelta = absA > absB
+            ? absA - absB
+            : absB - absA;
+
+        uint256 manualDelta;
+        if ((a >= 0 && b >= 0) || (a < 0 && b < 0)) {
+            manualDelta = absDelta;
+        }
+        // (a < 0 && b >= 0) || (a >= 0 && b < 0)
+        else {
+            manualDelta = absA + absB;
+        }
+
+        uint256 manualPercentDelta = manualDelta * 1e18 / absB;
+        uint256 percentDelta = stdMath.percentDelta(a, b);
+
+        assertEq(percentDelta, manualPercentDelta);
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                   HELPERS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    function getAbs(int256 a) private pure returns (uint256) {
+        if (a < 0)
+            return a == type(int256).min ? uint256(type(int256).max) + 1 : uint256(-a);
+
+        return uint256(a);
+    }
+}