@bgd-labs/aave-address-book 1.3.0 → 1.4.0

package/lib/forge-std/LICENSE-MIT

@@ -1,25 +0,0 @@
-Copyright (c) 2022 Brock Elmore
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE O THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.R

package/lib/forge-std/README.md

@@ -1,246 +0,0 @@
-# Forge Standard Library • [![tests](https://github.com/brockelmore/forge-std/actions/workflows/tests.yml/badge.svg)](https://github.com/brockelmore/forge-std/actions/workflows/tests.yml)
-
-Forge Standard Library is a collection of helpful contracts for use with [`forge` and `foundry`](https://github.com/foundry-rs/foundry). It leverages `forge`'s cheatcodes to make writing tests easier and faster, while improving the UX of cheatcodes.
-
-**Learn how to use Forge Std with the [📖 Foundry Book (Forge Std Guide)](https://book.getfoundry.sh/forge/forge-std.html).**
-
-## Install
-
-```bash
-forge install foundry-rs/forge-std
-```
-
-## Contracts
-### stdError
-
-This is a helper contract for errors and reverts. In `forge`, this contract is particularly helpful for the `expectRevert` cheatcode, as it provides all compiler builtin errors.
-
-See the contract itself for all error codes.
-
-#### Example usage
-
-```solidity
-
-import "forge-std/Test.sol";
-
-contract TestContract is Test {
-    ErrorsTest test;
-
-    function setUp() public {
-        test = new ErrorsTest();
-    }
-
-    function testExpectArithmetic() public {
-        vm.expectRevert(stdError.arithmeticError);
-        test.arithmeticError(10);
-    }
-}
-
-contract ErrorsTest {
-    function arithmeticError(uint256 a) public {
-        uint256 a = a - 100;
-    }
-}
-```
-
-### stdStorage
-
-This is a rather large contract due to all of the overloading to make the UX decent. Primarily, it is a wrapper around the `record` and `accesses` cheatcodes. It can *always* find and write the storage slot(s) associated with a particular variable without knowing the storage layout. The one _major_ caveat to this is while a slot can be found for packed storage variables, we can't write to that variable safely. If a user tries to write to a packed slot, the execution throws an error, unless it is uninitialized (`bytes32(0)`).
-
-This works by recording all `SLOAD`s and `SSTORE`s during a function call. If there is a single slot read or written to, it immediately returns the slot. Otherwise, behind the scenes, we iterate through and check each one (assuming the user passed in a `depth` parameter). If the variable is a struct, you can pass in a `depth` parameter which is basically the field depth.
-
-I.e.:
-```solidity
-struct T {
-    // depth 0
-    uint256 a;
-    // depth 1
-    uint256 b;
-}
-```
-
-#### Example usage
-
-```solidity
-import "forge-std/Test.sol";
-
-contract TestContract is Test {
-    using stdStorage for StdStorage;
-
-    Storage test;
-
-    function setUp() public {
-        test = new Storage();
-    }
-
-    function testFindExists() public {
-        // Lets say we want to find the slot for the public
-        // variable `exists`. We just pass in the function selector
-        // to the `find` command
-        uint256 slot = stdstore.target(address(test)).sig("exists()").find();
-        assertEq(slot, 0);
-    }
-
-    function testWriteExists() public {
-        // Lets say we want to write to the slot for the public
-        // variable `exists`. We just pass in the function selector
-        // to the `checked_write` command
-        stdstore.target(address(test)).sig("exists()").checked_write(100);
-        assertEq(test.exists(), 100);
-    }
-
-    // It supports arbitrary storage layouts, like assembly based storage locations
-    function testFindHidden() public {
-        // `hidden` is a random hash of a bytes, iteration through slots would
-        // not find it. Our mechanism does
-        // Also, you can use the selector instead of a string
-        uint256 slot = stdstore.target(address(test)).sig(test.hidden.selector).find();
-        assertEq(slot, uint256(keccak256("my.random.var")));
-    }
-
-    // If targeting a mapping, you have to pass in the keys necessary to perform the find
-    // i.e.:
-    function testFindMapping() public {
-        uint256 slot = stdstore
-            .target(address(test))
-            .sig(test.map_addr.selector)
-            .with_key(address(this))
-            .find();
-        // in the `Storage` constructor, we wrote that this address' value was 1 in the map
-        // so when we load the slot, we expect it to be 1
-        assertEq(uint(vm.load(address(test), bytes32(slot))), 1);
-    }
-
-    // If the target is a struct, you can specify the field depth:
-    function testFindStruct() public {
-        // NOTE: see the depth parameter - 0 means 0th field, 1 means 1st field, etc.
-        uint256 slot_for_a_field = stdstore
-            .target(address(test))
-            .sig(test.basicStruct.selector)
-            .depth(0)
-            .find();
-
-        uint256 slot_for_b_field = stdstore
-            .target(address(test))
-            .sig(test.basicStruct.selector)
-            .depth(1)
-            .find();
-
-        assertEq(uint(vm.load(address(test), bytes32(slot_for_a_field))), 1);
-        assertEq(uint(vm.load(address(test), bytes32(slot_for_b_field))), 2);
-    }
-}
-
-// A complex storage contract
-contract Storage {
-    struct UnpackedStruct {
-        uint256 a;
-        uint256 b;
-    }
-
-    constructor() {
-        map_addr[msg.sender] = 1;
-    }
-
-    uint256 public exists = 1;
-    mapping(address => uint256) public map_addr;
-    // mapping(address => Packed) public map_packed;
-    mapping(address => UnpackedStruct) public map_struct;
-    mapping(address => mapping(address => uint256)) public deep_map;
-    mapping(address => mapping(address => UnpackedStruct)) public deep_map_struct;
-    UnpackedStruct public basicStruct = UnpackedStruct({
-        a: 1,
-        b: 2
-    });
-
-    function hidden() public view returns (bytes32 t) {
-        // an extremely hidden storage slot
-        bytes32 slot = keccak256("my.random.var");
-        assembly {
-            t := sload(slot)
-        }
-    }
-}
-```
-
-### stdCheats
-
-This is a wrapper over miscellaneous cheatcodes that need wrappers to be more dev friendly. Currently there are only functions related to `prank`. In general, users may expect ETH to be put into an address on `prank`, but this is not the case for safety reasons. Explicitly this `hoax` function should only be used for address that have expected balances as it will get overwritten. If an address already has ETH, you should just use `prank`. If you want to change that balance explicitly, just use `deal`. If you want to do both, `hoax` is also right for you.
-
-
-#### Example usage:
-```solidity
-
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import "forge-std/Test.sol";
-
-// Inherit the stdCheats
-contract StdCheatsTest is Test {
-    Bar test;
-    function setUp() public {
-        test = new Bar();
-    }
-
-    function testHoax() public {
-        // we call `hoax`, which gives the target address
-        // eth and then calls `prank`
-        hoax(address(1337));
-        test.bar{value: 100}(address(1337));
-
-        // overloaded to allow you to specify how much eth to
-        // initialize the address with
-        hoax(address(1337), 1);
-        test.bar{value: 1}(address(1337));
-    }
-
-    function testStartHoax() public {
-        // we call `startHoax`, which gives the target address
-        // eth and then calls `startPrank`
-        //
-        // it is also overloaded so that you can specify an eth amount
-        startHoax(address(1337));
-        test.bar{value: 100}(address(1337));
-        test.bar{value: 100}(address(1337));
-        vm.stopPrank();
-        test.bar(address(this));
-    }
-}
-
-contract Bar {
-    function bar(address expectedSender) public payable {
-        require(msg.sender == expectedSender, "!prank");
-    }
-}
-```
-
-### Std Assertions
-
-Expand upon the assertion functions from the `DSTest` library.
-
-### `console.log`
-
-Usage follows the same format as [Hardhat](https://hardhat.org/hardhat-network/reference/#console-log).
-It's recommended to use `console2.sol` as shown below, as this will show the decoded logs in Forge traces.
-
-```solidity
-// import it indirectly via Test.sol
-import "forge-std/Test.sol";
-// or directly import it
-import "forge-std/console2.sol";
-...
-console2.log(someValue);
-```
-
-If you need compatibility with Hardhat, you must use the standard `console.sol` instead.
-Due to a bug in `console.sol`, logs that use `uint256` or `int256` types will not be properly decoded in Forge traces.
-
-```solidity
-// import it indirectly via Test.sol
-import "forge-std/Test.sol";
-// or directly import it
-import "forge-std/console.sol";
-...
-console.log(someValue);
-```