feat: adds a few more tips

.dapprc

@@ -0,0 +1,14 @@
+# Basic build/test configuration.
+export DAPP_SOLC_VERSION=0.8.11
+export DAPP_BUILD_OPTIMIZE=1
+export DAPP_BUILD_OPTIMIZE_RUNS=1000000
+export DAPP_LINK_TEST_LIBRARIES=0
+export DAPP_TEST_VERBOSITY=1
+export DAPP_TEST_SMTTIMEOUT=500000
+
+if [ "$DEEP_FUZZ" = "true" ]
+then
+  export DAPP_TEST_FUZZ_RUNS=10000 # Fuzz for a long time if DEEP_FUZZ is set to true.
+else
+  export DAPP_TEST_FUZZ_RUNS=100 # Only fuzz briefly if DEEP_FUZZ is not set to true.
+fi

.gitattributes

@@ -0,0 +1 @@
+*.sol linguist-language=Solidity

.gitignore

@@ -0,0 +1,2 @@
+/out
+cache/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/ds-test"]
+	path = lib/ds-test
+	url = https://github.com/dapphub/ds-test

Makefile

@@ -0,0 +1,4 @@
+all    :; dapp build
+clean  :; dapp clean
+test   :; dapp test
+deploy :; dapp create GolfCourse

README.md

@@ -1,21 +1,170 @@
 # golf-course
 A list of common Solidity optimization tips and myths.
 
-## Tips
 
-### Right Shift Instead of Dividing By 2
+# Tips
 
-The `SHR` opcode is 3 gas cheaper than `DIV` and also bypasses Solidity's division by 0 prevention overhead.
+- - - -
+### Use `uint` instead of `bool` for reentrancy guard ###
 
-- [Gas Usage]()
-- [Full Example]()
+```solidity
+/// 🤦 Unoptimized (gas: 22202)
+
+bool private locked = false;
+modifier nonReentrant() {
+    require(locked == false, "REENTRANCY");
+    locked = true;
+    _;
+    locked = false;
+}
+
+/// 🚀 Optimized (gas: 2125)
+bool private locked = 1;
+modifier nonReentrant() {
+    require(locked == 1, "REENTRANCY");
+    locked = 2;
+    _;
+    locked = 1;
+}
+```
+
+Use a reentrancy guard like [Solmate](https://github.com/Rari-Capital/solmate/blob/main/src/utils/ReentrancyGuard.sol) which employs `uint` instead of `bool` storage variable which saves gas.  The initial `SSTORE` of _true_ in the unoptimized version costs over 20,000 gas while the second SSTORE of _false_ costs only 100.  But both `SSTORE` (for 2 and 1) cost only 100 gas.
+  - [Full Example](https://github.com/Rari-Capital/golf-course/blob/fc1882bacfec50787d9e9435d59fed4a9091fb21/src/optimized/Reentrancy.sol)
+
+- - - -
+### When iterating through a storage array, cache the array length first ###
 
 ```solidity
-// Unoptimized:
-uint256 two = 4 / 2;
+uint256[] public arr = [uint256(1), 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
-// Optimized:
-uint256 two = 4 >> 1;
+/// 🤦 Unoptimized (gas: 3055)
+for (uint256 index; index < arr.length; ++index) {}
+
+/// 🚀 Optimized (gas: 2013)
+uint256 arrLength = arr.length;
+for (uint256 index; index < arrLength; ++index) {}
 ```
+Caching the array length first saves an `SLOAD` on each iteration of the loop.
+  - [Full Example](https://github.com/Rari-Capital/golf-course/blob/fc1882bacfec50787d9e9435d59fed4a9091fb21/src/optimized/CacheArrLength.sol)
+
+- - - -
+### Use unchecked with counter incrementing logic ###
+
+```solidity
+
+/// 🤦 Unoptimized (gas: 2035)
+for (uint256 index; index < arrLength; ++index) {}
+
+
+/// 🚀 Optimized (gas: 1375)
+function _uncheckedIncrement(uint256 counter) private pure returns(uint256) {
+    unchecked {
+        return counter + 1;
+    }
+}
+...
+for (uint256 index; index < arrLength; index = _uncheckedIncrement(index)) {}
+```
+It is a logical impossibility for index to overflow if it is always less than another integer (`index < arrLength`).  Skipping the unchecked saves ~60 gas per iteration.  Note: Part of the savings here comes from the fact that as of Solidity 0.8.2, the compiler will inline this function automatically.  Using an older pragma would reduce the gas savings. For additional info see [hrkrshnn's writeup](https://gist.github.com/hrkrshnn/ee8fabd532058307229d65dcd5836ddc)
+  - [Full Example](https://github.com/Rari-Capital/golf-course/blob/fc1882bacfec50787d9e9435d59fed4a9091fb21/src/optimized/UncheckedIncrement.sol)
+
+
+- - - -
+### Use `++index` instead of `index++` to increment a loop counter ###
+
+```solidity
+/// 🤦 Unoptimized (gas: 2064)
+for (uint256 index; index < arrLength; index++) {}
+
+/// 🚀 Optimized (gas: 2014)
+for (uint256 index; index < arrLength; ++index) {}
+```
+Due to reduced stack operations, using `++index` saves 5 gas per iteration
+  - [Full Example](https://github.com/Rari-Capital/golf-course/blob/fc1882bacfec50787d9e9435d59fed4a9091fb21/src/optimized/PlusPlusIndex.sol)
+
+- - - -
+### Prefer using `immutable` to `storage` ###
+
+```solidity
+uint256 public immutableNumber;
+uint256 public storageNumber;
+
+/// 🤦 Unoptimized (gas: 1042)
+uint256 sum = storageNumber + 1;
+    }
+/// 🚀 Optimized (gas: 1024)
+uint256 sum = immutableNumber + 1;
+```
+Each storage read of the state variable is replaced by the instruction `PUSH32` value, where value is set during contract construction time. For additional info see [hrkrshnn's writeup](https://gist.github.com/hrkrshnn/ee8fabd532058307229d65dcd5836ddc)
+  - [Full Example](https://github.com/Rari-Capital/golf-course/blob/fc1882bacfec50787d9e9435d59fed4a9091fb21/src/optimized/UseImmutable.sol)
+
+- - - -
+### Make functions `payable` ###
+
+```solidity
+
+/// 🤦 Unoptimized (gas: 781)
+function doSomething() external pure {}
+
+/// 🚀 Optimized (gas: 760)
+function doSomething() payable external {}
+```
+Making functions `payable` eliminates the need for an initial check of `msg.value == 0` and saves 21 gas. Note: This conservatively assumes the function could be `pure` if not for the `payable`.  When compared against a non-`pure` function the savings is more (24 gas). When used for a constructor, the savings is on deployment. Note: For certain contracts, adding a `payable` function where none existed previously could introduce a security risk. Use with caution.
+  - [Full Example](https://github.com/Rari-Capital/golf-course/blob/fc1882bacfec50787d9e9435d59fed4a9091fb21/src/optimized/PayableFunctions.sol)
+
+- - - -
+### For array elements, arr[i] = arr[i] + 1 is cheaper than arr[i] += 1 ###
+
+```solidity
+uint256[2] public arr = [uint256(1), 2]; // storage
+
+/// 🤦 Unoptimized (gas: 1110)
+arr[0] += 1;
+
+/// 🚀 Optimized (gas: 1085)
+arr[0] = arr[0] + 1;
+```
+Due to stack operations this is 25 gas cheaper when dealing with arrays in storage, and 4 gas cheaper for memory arrays.
+  - [Full Example](https://github.com/Rari-Capital/golf-course/blob/fc1882bacfec50787d9e9435d59fed4a9091fb21/src/optimized/ArrayPlus.sol)
+
+- - - -
+### When dividing by two, use `>> 1` instead of `/ 2` ###
+
+```solidity
+uint256 four = 4;
+uint256 two;
+
+/// 🤦 Unoptimized (gas: 1012)
+two = four / 2;
+
+/// 🚀 Optimized (gas: 933)
+two = four >> 1;
+```
+
+The `SHR` opcode is 3 gas cheaper than `DIV` and more imporantly, bypasses Solidity's division by 0 prevention overhead.  This can be used not only when dividing by two, but with any exponent of 2.
+  - [Full Example](https://github.com/Rari-Capital/golf-course/blob/fc1882bacfec50787d9e9435d59fed4a9091fb21/src/optimized/DivideByTwo.sol)
+
+
+- - - -
+### In `require()`, use `!= 0` instead of `> 0` with `uint` values ###
+
+```solidity
+uint256 notZero = 4;
+
+/// 🤦 Unoptimized (gas: 867)
+require(notZero > 0);
+
+/// 🚀 Optimized (gas: 861)
+require(notZero != 0);
+```
+In a require, when checking a `uint`, using `!= 0` instead of `> 0` saves 6 gas. Note: This only works in require but not in other situations.  For more info see [this thread](https://twitter.com/transmissions11/status/1469848358558711808?s=20&t=hyTZxmZKXq06opE8wgo1aA)
+  - [Full Example](https://github.com/Rari-Capital/golf-course/blob/fc1882bacfec50787d9e9435d59fed4a9091fb21/src/optimized/RequireNeZero.sol)
+
+
+
+
+# Myths
+- - - -
+
+
 
-## Myths

src/contracts/optimized/ArrayPlus.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract ArrayPlus {
+    uint256[2] public arr = [uint256(1), 2];
+
+    function arrayPlus() external {
+        /// 🚀 Optimized
+        arr[0] = arr[0] + 4;
+    }
+
+}

src/contracts/optimized/CacheArrLength.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract CacheArrLength {
+    uint256[] public arr = [uint256(1), 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+    function cacheArrLength() external view {
+        uint256 arrLength = arr.length;
+
+        /// 🚀 Optimized
+        for (uint256 index; index < arrLength; ++index) {}
+    }
+
+}

src/contracts/optimized/DivideByTwo.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract DivideByTwo {
+    function divideByTwo(uint256 four) external pure returns (uint256 two) {
+        /// 🚀 Optimized
+        two = four >> 1;
+    }
+
+}

src/contracts/optimized/PayableFunctions.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract PayableFunctions {
+    /// 🚀 Optimized
+    function payableFunctions() payable external {
+    }
+
+}

src/contracts/optimized/PlusPlusIndex.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract PlusPlusIndex {
+    uint256[] public arr = [uint256(1), 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+    function plusPlusIndex() external view {
+        uint256 arrLength = arr.length;
+
+        /// 🚀 Optimized
+        for (uint256 index; index < arrLength; ++index) {}
+    }
+
+}

src/contracts/optimized/Reentrancy.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract Reentrancy {
+    event GenericEvent();
+
+
+    uint256 private locked = 1;
+
+    modifier nonReentrant() {
+        /// 🚀 Optimized
+        require(locked == 1, "REENTRANCY");
+        locked = 2;
+        _;
+        locked = 1;
+    }
+    function useUintForReentrancy() external nonReentrant returns(uint256 amount3) {
+        // do some stuff
+        uint256 amount1 = 1e18;
+        uint256 amount2 = 1e18;
+        amount3 = amount1 + amount2;
+        emit GenericEvent();
+    }
+}

src/contracts/optimized/RequireNeZero.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract RequireNeZero {
+    function requireNeZero(uint256 notZero) external pure {
+        /// 🚀 Optimized
+        require(notZero != 0);
+    }
+
+}

src/contracts/optimized/UncheckedIncrement.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract UncheckedIncrement {
+    uint256[] public arr = [uint256(1), 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+    function _uncheckedIncrement(uint256 counter) private pure returns(uint256) {
+        unchecked {
+            return counter + 1;
+        }
+    }
+    function uncheckedIncrement() external view {
+        uint256 arrLength = arr.length;
+
+        /// 🚀 Optimized
+        for (uint256 index; index < arrLength; index = _uncheckedIncrement(index)) {}
+    }
+
+}

src/contracts/optimized/UseImmutable.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract UseImmutable {
+    uint256 public immutableNumber;
+    uint256 public storageNumber;
+
+    constructor() {
+        immutableNumber = 1;
+        storageNumber = 1;
+    }
+    function useImmutable() external view returns(uint256) {
+        /// 🚀 Optimized
+        return immutableNumber + 1;
+    }
+
+}

src/contracts/unoptimized/ArrayPlus.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract ArrayPlus {
+    uint256[2] public arr = [uint256(1), 2];
+
+    function arrayPlus() external {
+        /// 🚀 Optimized
+        arr[0] += 4;
+    }
+
+}

src/contracts/unoptimized/CacheArrLength.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract CacheArrLength {
+    uint256[] public arr = [uint256(1), 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+    function cacheArrLength() external view {
+        /// 🤦 Unoptimized
+
+        for (uint256 index; index < arr.length; ++index) {}
+    }
+
+}

src/contracts/unoptimized/DivideByTwo.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract DivideByTwo {
+
+    function divideByTwo(uint256 four) external pure returns (uint256 two) {
+        /// 🤦 Unoptimized
+        two = four / 2;
+    }
+
+}

src/contracts/unoptimized/PayableFunctions.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.11;
+
+contract PayableFunctions {
+
+    /// 🤦 Unoptimized
+    function payableFunctions() external pure {
+    }
+
+}