feat: add integer overflow/underflow security demos

Author: MilosMicun

src/OverflowChecked.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract OverflowChecked {
+    function add(uint256 a, uint256 b) external pure returns (uint256) {
+        return a + b;
+    }
+
+    function sub(uint256 a, uint256 b) external pure returns (uint256) {
+        return a - b;
+    }
+}

src/OverflowLegacy.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract OverflowLegacy {
+    function add(uint256 a, uint256 b) external pure returns (uint256) {
+        unchecked {
+            return a + b;
+        }
+    }
+
+    function sub(uint256 a, uint256 b) external pure returns (uint256) {
+        unchecked {
+            return a - b;
+        }
+    }
+}

src/OverflowUnchecked.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract OverflowUnchecked {
+    error Overflow();
+    error Underflow();
+
+    function add(uint256 a, uint256 b) external pure returns (uint256) {
+        if (a > type(uint256).max - b) revert Overflow();
+
+        unchecked {
+            return a + b;
+        }
+    }
+
+    function sub(uint256 a, uint256 b) external pure returns (uint256) {
+        if (a < b) revert Underflow();
+
+        unchecked {
+            return a - b;
+        }
+    }
+
+    function addWrap(uint256 a, uint256 b) external pure returns (uint256) {
+        unchecked {
+            return a + b;
+        }
+    }
+
+    function subWrap(uint256 a, uint256 b) external pure returns (uint256) {
+        unchecked {
+            return a - b;
+        }
+    }
+}

test/Overflow.t.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {OverflowLegacy} from "../src/OverflowLegacy.sol";
+import {OverflowChecked} from "../src/OverflowChecked.sol";
+import {OverflowUnchecked} from "../src/OverflowUnchecked.sol";
+
+contract overflowTest is Test {
+    OverflowLegacy legacy;
+    OverflowChecked checked;
+    OverflowUnchecked uncheckedDemo;
+
+    function setUp() public {
+        legacy = new OverflowLegacy();
+        checked = new OverflowChecked();
+        uncheckedDemo = new OverflowUnchecked();
+    }
+
+    function testLegacyAddWrapsToZero() public {
+        uint256 result = legacy.add(type(uint256).max, 1);
+        assertEq(result, 0);
+    }
+
+    function testLegacySubWrapsToMax() public {
+        uint256 result = legacy.sub(0, 1);
+        assertEq(result, type(uint256).max);
+    }
+
+    function testCheckedAddRevertsOnOverflow() public {
+        vm.expectRevert();
+        checked.add(type(uint256).max, 1);
+    }
+
+    function testCheckedSubRevertsOnUnderflow() public {
+        vm.expectRevert();
+        checked.sub(0, 1);
+    }
+
+    function testUncheckedAddWithGuardWorks() public {
+        uint256 result = uncheckedDemo.add(10, 20);
+        assertEq(result, 30);
+    }
+
+    function testUncheckedSubWithGuardWorks() public {
+        uint256 result = uncheckedDemo.sub(20, 10);
+        assertEq(result, 10);
+    }
+
+    function testUncheckedAddRevertsWhenGuardFails() public {
+        vm.expectRevert(OverflowUnchecked.Overflow.selector);
+        uncheckedDemo.add(type(uint256).max, 1);
+    }
+
+    function testUncheckedSubRevertsWhenGuardFails() public {
+        vm.expectRevert(OverflowUnchecked.Underflow.selector);
+        uncheckedDemo.sub(0, 1);
+    }
+
+    function testUncheckedAddWrapFunctionWrapsToZero() public {
+        uint256 result = uncheckedDemo.addWrap(type(uint256).max, 1);
+        assertEq(result, 0);
+    }
+
+    function testUncheckedSubWrapFunctionWrapsToMax() public {
+        uint256 result = uncheckedDemo.subWrap(0, 1);
+        assertEq(result, type(uint256).max);
+    }
+}