initial random bytes and eip1271 offerer

jameswenzel · GitHub Actions Bot · commit 82aabed581b9 · 2023-04-10T11:21:52.000-07:00
diff --git a/scripts/find_optimizer_runs.sh b/scripts/find_optimizer_runs.sh
@@ -0,0 +1,58 @@
+#!/bin/bash
+# h/t @DrakeEvansV1 & ChatGPT
+
+TARGET_SIZE=24.576
+MIN_RUNS=1
+# NOTE that at time of writing, Etherscan does not support verifying contracts
+# that specify more than 10,000,000 optimizer runs.
+# Higher numbers do not always result in different bytecode output. If a
+# higher number of runs is used, it may be possible verify by spoofing with a
+# number that results in the same bytecode output. This is not guaranteed.
+MAX_RUNS=$((2**32-1))
+ENV_FILE=".env"
+FOUND_RUNS=0
+
+# Check if the optimizer is enabled
+OPTIMIZER_STATUS=$(forge config | grep optimizer | head -n 1)
+if [ "$OPTIMIZER_STATUS" != "optimizer = true" ]; then
+    echo "Error: The optimizer is not enabled. Please enable it and try again."
+    exit 1
+fi
+
+try_runs() {
+    local RUNS=$1
+    printf "Trying with FOUNDRY_OPTIMIZER_RUNS=%d\n" "$RUNS"
+    RESULT=$(FOUNDRY_OPTIMIZER_RUNS=$RUNS forge build --sizes | grep Seaport | head -n 1)
+    CONTRACT_SIZE=$(echo $RESULT | awk -F'|' '{print $3}' | awk '{print $1}')
+    [ "$(echo "$CONTRACT_SIZE<=$TARGET_SIZE" | bc)" -eq 1 ]
+}
+
+if try_runs $MAX_RUNS; then
+    FOUND_RUNS=$MAX_RUNS
+else
+    while [ $MIN_RUNS -le $MAX_RUNS ]; do
+        MID_RUNS=$(( (MIN_RUNS + MAX_RUNS) / 2 ))
+        
+        if try_runs $MID_RUNS; then
+            printf "Success with FOUNDRY_OPTIMIZER_RUNS=%d and contract size %.3fKB\n" "$MID_RUNS" "$CONTRACT_SIZE"
+            MIN_RUNS=$((MID_RUNS + 1))
+            FOUND_RUNS=$MID_RUNS
+        else
+            printf "Failure with FOUNDRY_OPTIMIZER_RUNS=%d and contract size %.3fKB\n" "$MID_RUNS" "$CONTRACT_SIZE"
+            MAX_RUNS=$((MID_RUNS - 1))
+        fi
+    done
+fi
+
+printf "Highest FOUNDRY_OPTIMIZER_RUNS found: %d\n" "$FOUND_RUNS"
+
+if [ -f "$ENV_FILE" ]; then
+    if grep -q "^FOUNDRY_OPTIMIZER_RUNS=" "$ENV_FILE"; then
+        awk -v runs="$FOUND_RUNS" '{gsub(/^FOUNDRY_OPTIMIZER_RUNS=.*/, "FOUNDRY_OPTIMIZER_RUNS="runs); print}' "$ENV_FILE" > "$ENV_FILE.tmp" && mv "$ENV_FILE.tmp" "$ENV_FILE"
+    else
+        echo "FOUNDRY_OPTIMIZER_RUNS=$FOUND_RUNS" >> "$ENV_FILE"
+    fi
+    printf "Updated %s with FOUNDRY_OPTIMIZER_RUNS=%d\n" "$ENV_FILE" "$FOUND_RUNS"
+else
+    printf "Error: %s not found.\n" "$ENV_FILE"
+fi
diff --git a/test/foundry/new/helpers/EIP1271Offerer.sol b/test/foundry/new/helpers/EIP1271Offerer.sol
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+contract EIP1271Offerer {
+    error InvalidSignature(bytes32 digest, bytes signature);
+    bytes4 private constant _EIP_1271_MAGIC_VALUE = 0x1626ba7e;
+
+    mapping(bytes32 => bytes32) public digestToSignatureHash;
+
+    function registerSignature(bytes32 digest, bytes memory signature) public {
+        digestToSignatureHash[digest] = keccak256(signature);
+    }
+
+    function isValidSignature(
+        bytes32 digest,
+        bytes memory signature
+    ) external view returns (bytes4) {
+        bytes32 signatureHash = keccak256(signature);
+        if (digestToSignatureHash[digest] == signatureHash) {
+            return _EIP_1271_MAGIC_VALUE;
+        }
+        revert InvalidSignature(digest, signature);
+    }
+}
diff --git a/test/foundry/new/helpers/RandomBytes.sol b/test/foundry/new/helpers/RandomBytes.sol
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+import { LibPRNG } from "solady/src/utils/LibPRNG.sol";
+
+library RandomBytes {
+    uint256 constant MAX_RANDOM_LENGTH = 1000;
+
+    function randomBytes(
+        LibPRNG.PRNG memory prng,
+        uint256 length
+    ) internal pure returns (bytes memory) {
+        bytes memory bytesArray = new bytes(length);
+        // track the number of bytes we've written
+        uint256 i;
+        // loop until we've written `length` bytes
+        while (i < length) {
+            // get a random chunk of 32 bytes
+            bytes32 randomChunk = bytes32(LibPRNG.next(prng));
+            // loop through the chunk and write each byte to the output
+            // stop if we've written `length` bytes
+            for (uint256 j; j < 32 && i < length; ) {
+                bytesArray[i] = randomChunk[j];
+                unchecked {
+                    // increment both counters
+                    ++i;
+                    ++j;
+                }
+            }
+        }
+        return bytesArray;
+    }
+
+    function randomBytes(
+        LibPRNG.PRNG memory prng
+    ) internal pure returns (bytes memory) {
+        // get a random length between 1 and MAX_RANDOM_LENGTH
+        uint256 length = (LibPRNG.next(prng) % MAX_RANDOM_LENGTH) + 1;
+        return randomBytes(prng, length);
+    }
+}
diff --git a/test/foundry/new/helpers/RandomBytes.t.sol b/test/foundry/new/helpers/RandomBytes.t.sol
@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { Test } from "forge-std/Test.sol";
+import { RandomBytes } from "./RandomBytes.sol";
+import { LibPRNG } from "solady/src/utils/LibPRNG.sol";
+
+contract RandomBytesTest is Test {
+    function testRandomBytes() public {
+        LibPRNG.PRNG memory prng = LibPRNG.PRNG(0);
+        bytes memory bytesArray = RandomBytes.randomBytes(prng, 100);
+        assertEq(bytesArray.length, 100, "randomBytes length");
+        // assert not more than 5 0 bytes in a row
+        // this will fail 1/2^40 times
+        uint256 zeroCount = 0;
+        for (uint256 i = 0; i < bytesArray.length; i++) {
+            if (bytesArray[i] == 0) {
+                zeroCount++;
+            } else {
+                zeroCount = 0;
+            }
+            assertLt(zeroCount, 6, "randomBytes zero count");
+        }
+    }
+
+    function testRandomBytes(uint256 seed) public {
+        LibPRNG.PRNG memory prng = LibPRNG.PRNG(seed);
+        bytes memory bytesArray = RandomBytes.randomBytes(prng, 100);
+        assertEq(bytesArray.length, 100, "randomBytes length");
+        // assert not more than 5 0 bytes in a row
+        // this will fail 1/2^40 times :(
+        uint256 zeroCount = 0;
+        for (uint256 i = 0; i < bytesArray.length; i++) {
+            if (bytesArray[i] == 0) {
+                zeroCount++;
+            } else {
+                zeroCount = 0;
+            }
+            assertLt(zeroCount, 6, "randomBytes zero count");
+        }
+    }
+
+    function testRandomBytesRandomLength() public {
+        LibPRNG.PRNG memory prng = LibPRNG.PRNG(0);
+        bytes memory bytesArray = RandomBytes.randomBytes(prng);
+        assertLt(bytesArray.length, 1001, "randomBytes length");
+        assertGt(bytesArray.length, 0, "randomBytes length");
+        // assert not more than 5 0 bytes in a row
+        // this will fail 1/2^40 times
+        uint256 zeroCount = 0;
+        for (uint256 i = 0; i < bytesArray.length; i++) {
+            if (bytesArray[i] == 0) {
+                zeroCount++;
+            } else {
+                zeroCount = 0;
+            }
+            assertLt(zeroCount, 6, "randomBytes zero count");
+        }
+    }
+
+    function testRandomBytesRandomLength(uint256 seed) public {
+        LibPRNG.PRNG memory prng = LibPRNG.PRNG(seed);
+        bytes memory bytesArray = RandomBytes.randomBytes(prng);
+        assertLt(bytesArray.length, 1001, "randomBytes length");
+        assertGt(bytesArray.length, 0, "randomBytes length");
+        // assert not more than 5 0 bytes in a row
+        // this will fail 1/2^40 times
+        uint256 zeroCount = 0;
+        for (uint256 i = 0; i < bytesArray.length; i++) {
+            if (bytesArray[i] == 0) {
+                zeroCount++;
+            } else {
+                zeroCount = 0;
+            }
+            assertLt(zeroCount, 6, "randomBytes zero count");
+        }
+    }
+}
