web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/test/utils/Base58.t.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+import {Test} from "forge-std/Test.sol";
+import {Base58} from "@openzeppelin/contracts/utils/Base58.sol";
+
+contract Base58Test is Test {
+    function testEncodeDecodeEmpty() external pure {
+        assertEq(Base58.decode(Base58.encode(hex"")), hex"");
+    }
+
+    function testEncodeDecodeZeros() external pure {
+        bytes memory zeros = hex"0000000000000000";
+        assertEq(Base58.decode(Base58.encode(zeros)), zeros);
+
+        bytes memory almostZeros = hex"00000000a400000000";
+        assertEq(Base58.decode(Base58.encode(almostZeros)), almostZeros);
+    }
+
+    function testEncodeDecode(bytes memory input) external pure {
+        assertEq(Base58.decode(Base58.encode(input)), input);
+    }
+}

package/lib/openzeppelin-contracts/test/utils/Base58.test.js

@@ -0,0 +1,65 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+async function fixture() {
+  const mock = await ethers.deployContract('$Base58');
+  return { mock };
+}
+
+describe('Base58', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('base58', function () {
+    describe('encode/decode random buffers', function () {
+      // length 512 runs out of gas.
+      // this checks are very slow when running coverage, causing CI to timeout.
+      for (const length of [0, 1, 2, 3, 4, 32, 42, 128, 384])
+        it(
+          [length > 32 && '[skip-on-coverage]', `buffer of length ${length}`].filter(Boolean).join(' '),
+          async function () {
+            const buffer = ethers.randomBytes(length);
+            const hex = ethers.hexlify(buffer);
+            const b58 = ethers.encodeBase58(buffer);
+
+            await expect(this.mock.$encode(hex)).to.eventually.equal(b58);
+            await expect(this.mock.$decode(b58)).to.eventually.equal(hex);
+          },
+        );
+    });
+
+    // Tests case from section 5 of the (no longer active) Base58 Encoding Scheme RFC
+    // https://datatracker.ietf.org/doc/html/draft-msporny-base58-03
+    describe('test vectors', function () {
+      for (const { raw, b58 } of [
+        { raw: 'Hello World!', b58: '2NEpo7TZRRrLZSi2U' },
+        {
+          raw: 'The quick brown fox jumps over the lazy dog.',
+          b58: 'USm3fpXnKG5EUBx2ndxBDMPVciP5hGey2Jh4NDv6gmeo1LkMeiKrLJUUBk6Z',
+        },
+        { raw: '0x0000287fb4cd', b58: '11233QC4' },
+      ])
+        it(raw, async function () {
+          const buffer = (ethers.isHexString(raw) ? ethers.getBytes : ethers.toUtf8Bytes)(raw);
+          const hex = ethers.hexlify(buffer);
+
+          await expect(this.mock.$encode(hex)).to.eventually.equal(b58);
+          await expect(this.mock.$decode(b58)).to.eventually.equal(hex);
+        });
+    });
+
+    describe('decode invalid format', function () {
+      for (const chr of ['I', '-', '~'])
+        it(`Invalid base58 char ${chr}`, async function () {
+          const getHexCode = str => ethers.hexlify(ethers.toUtf8Bytes(str));
+          const helper = { interface: ethers.Interface.from(['error InvalidBase58Char(bytes1)']) };
+
+          await expect(this.mock.$decode(`VYRWKp${chr}pnN7`))
+            .to.be.revertedWithCustomError(helper, 'InvalidBase58Char')
+            .withArgs(getHexCode(chr));
+        });
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/utils/Base64.t.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {Base64} from "@openzeppelin/contracts/utils/Base64.sol";
+
+contract Base64Test is Test {
+    function testEncode(bytes memory input) external pure {
+        assertEq(Base64.encode(input), vm.toBase64(input));
+        assertEq(Base64.decode(Base64.encode(input)), input);
+    }
+
+    function testEncodeURL(bytes memory input) external pure {
+        assertEq(Base64.encodeURL(input), _removePadding(vm.toBase64URL(input)));
+        assertEq(Base64.decode(Base64.encodeURL(input)), input);
+    }
+
+    function _removePadding(string memory inputStr) internal pure returns (string memory) {
+        bytes memory input = bytes(inputStr);
+        bytes memory output;
+
+        for (uint256 i = 0; i < input.length; ++i) {
+            if (input[input.length - i - 1] != 0x3d) {
+                output = new bytes(input.length - i);
+                break;
+            }
+        }
+
+        for (uint256 i = 0; i < output.length; ++i) {
+            output[i] = input[i];
+        }
+
+        return string(output);
+    }
+}

package/lib/openzeppelin-contracts/test/utils/Base64.test.js

@@ -0,0 +1,79 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+// Replace "+/" with "-_" in the char table, and remove the padding
+// see https://datatracker.ietf.org/doc/html/rfc4648#section-5
+const base64toBase64Url = str => str.replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', '');
+
+async function fixture() {
+  const mock = await ethers.deployContract('$Base64');
+  return { mock };
+}
+
+describe('Base64', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('base64', function () {
+    for (const { title, input, expected } of [
+      { title: 'converts to base64 encoded string with double padding', input: 'test', expected: 'dGVzdA==' },
+      { title: 'converts to base64 encoded string with single padding', input: 'test1', expected: 'dGVzdDE=' },
+      { title: 'converts to base64 encoded string without padding', input: 'test12', expected: 'dGVzdDEy' },
+      { title: 'converts to base64 encoded string (/ case)', input: 'où', expected: 'b/k=' },
+      { title: 'converts to base64 encoded string (+ case)', input: 'zs~1t8', expected: 'enN+MXQ4' },
+      { title: 'empty bytes', input: '', expected: '' },
+    ])
+      it(title, async function () {
+        const buffer = Buffer.from(input, 'ascii');
+        await expect(this.mock.$encode(buffer)).to.eventually.equal(ethers.encodeBase64(buffer));
+        await expect(this.mock.$encode(buffer)).to.eventually.equal(expected);
+        await expect(this.mock.$decode(expected)).to.eventually.equal(ethers.hexlify(buffer));
+      });
+  });
+
+  describe('base64url', function () {
+    for (const { title, input, expected } of [
+      { title: 'converts to base64url encoded string with double padding', input: 'test', expected: 'dGVzdA' },
+      { title: 'converts to base64url encoded string with single padding', input: 'test1', expected: 'dGVzdDE' },
+      { title: 'converts to base64url encoded string without padding', input: 'test12', expected: 'dGVzdDEy' },
+      { title: 'converts to base64url encoded string (_ case)', input: 'où', expected: 'b_k' },
+      { title: 'converts to base64url encoded string (- case)', input: 'zs~1t8', expected: 'enN-MXQ4' },
+      { title: 'empty bytes', input: '', expected: '' },
+    ])
+      it(title, async function () {
+        const buffer = Buffer.from(input, 'ascii');
+        await expect(this.mock.$encodeURL(buffer)).to.eventually.equal(base64toBase64Url(ethers.encodeBase64(buffer)));
+        await expect(this.mock.$encodeURL(buffer)).to.eventually.equal(expected);
+        await expect(this.mock.$decode(expected)).to.eventually.equal(ethers.hexlify(buffer));
+      });
+  });
+
+  it('Decode invalid base64 string', async function () {
+    const getHexCode = str => ethers.hexlify(ethers.toUtf8Bytes(str));
+    const helper = { interface: ethers.Interface.from(['error InvalidBase64Char(bytes1)']) };
+
+    // ord('*') < 43
+    await expect(this.mock.$decode('dGVzd*=='))
+      .to.be.revertedWithCustomError(helper, 'InvalidBase64Char')
+      .withArgs(getHexCode('*'));
+    // ord('{') > 122
+    await expect(this.mock.$decode('dGVzd{=='))
+      .to.be.revertedWithCustomError(helper, 'InvalidBase64Char')
+      .withArgs(getHexCode('{'));
+    // ord('@') in range, but '@' not in the dictionary
+    await expect(this.mock.$decode('dGVzd@=='))
+      .to.be.revertedWithCustomError(helper, 'InvalidBase64Char')
+      .withArgs(getHexCode('@'));
+  });
+
+  it('Encode reads beyond the input buffer into dirty memory', async function () {
+    const mock = await ethers.deployContract('Base64Dirty');
+    const buffer32 = ethers.id('example');
+    const buffer31 = buffer32.slice(0, -2);
+
+    await expect(mock.encode(buffer31)).to.eventually.equal(ethers.encodeBase64(buffer31));
+    await expect(mock.encode(buffer32)).to.eventually.equal(ethers.encodeBase64(buffer32));
+  });
+});

package/lib/openzeppelin-contracts/test/utils/Blockhash.t.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {Test} from "forge-std/Test.sol";
+import {Blockhash} from "../../contracts/utils/Blockhash.sol";
+
+contract BlockhashTest is Test {
+    uint256 internal startingBlock;
+
+    address internal constant SYSTEM_ADDRESS = 0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE;
+
+    // See https://eips.ethereum.org/EIPS/eip-2935#bytecode
+    // Generated using https://www.evm.codes/playground
+    bytes private constant HISTORY_STORAGE_BYTECODE =
+        hex"3373fffffffffffffffffffffffffffffffffffffffe14604657602036036042575f35600143038111604257611fff81430311604257611fff9006545f5260205ff35b5f5ffd5b5f35611fff60014303065500";
+
+    function setUp() public {
+        vm.roll(block.number + 100);
+
+        startingBlock = block.number;
+        vm.etch(Blockhash.HISTORY_STORAGE_ADDRESS, HISTORY_STORAGE_BYTECODE);
+    }
+
+    function testFuzzRecentBlocks(uint8 offset, uint64 currentBlock, bytes32 expectedHash) public {
+        // Recent blocks (1-256 blocks old)
+        uint256 boundedOffset = uint256(offset) + 1;
+        vm.assume(currentBlock > boundedOffset);
+        vm.roll(currentBlock);
+
+        uint256 targetBlock = currentBlock - boundedOffset;
+        vm.setBlockhash(targetBlock, expectedHash);
+
+        bytes32 result = Blockhash.blockHash(targetBlock);
+        assertEq(result, blockhash(targetBlock));
+        assertEq(result, expectedHash);
+    }
+
+    function testFuzzHistoryBlocks(uint16 offset, uint256 currentBlock, bytes32 expectedHash) public {
+        // History blocks (257-8191 blocks old)
+        offset = uint16(bound(offset, 257, 8191));
+        vm.assume(currentBlock > offset);
+        vm.roll(currentBlock);
+
+        uint256 targetBlock = currentBlock - offset;
+        _setHistoryBlockhash(targetBlock, expectedHash);
+
+        bytes32 result = Blockhash.blockHash(targetBlock);
+        (bool success, bytes memory returndata) = Blockhash.HISTORY_STORAGE_ADDRESS.staticcall(
+            abi.encodePacked(bytes32(targetBlock))
+        );
+        assertTrue(success);
+        assertEq(result, abi.decode(returndata, (bytes32)));
+        assertEq(result, expectedHash);
+    }
+
+    function testFuzzVeryOldBlocks(uint256 offset, uint256 currentBlock) public {
+        // Very old blocks (>8191 blocks old)
+        offset = bound(offset, 8192, type(uint256).max);
+        vm.assume(currentBlock > offset);
+        vm.roll(currentBlock);
+
+        uint256 targetBlock = currentBlock - offset;
+        bytes32 result = Blockhash.blockHash(targetBlock);
+        assertEq(result, bytes32(0));
+    }
+
+    function testFuzzFutureBlocks(uint256 offset, uint256 currentBlock) public {
+        // Future blocks
+        offset = bound(offset, 1, type(uint256).max);
+        currentBlock = bound(currentBlock, 0, type(uint256).max - offset);
+        vm.roll(currentBlock);
+
+        unchecked {
+            uint256 targetBlock = currentBlock + offset;
+            bytes32 result = Blockhash.blockHash(targetBlock);
+            assertEq(result, blockhash(targetBlock));
+        }
+    }
+
+    function testUnsupportedChainsReturnZeroWhenOutOfRange() public {
+        vm.etch(Blockhash.HISTORY_STORAGE_ADDRESS, hex"");
+
+        vm.roll(block.number + 1000);
+        assertEq(Blockhash.blockHash(block.number - 1000), bytes32(0));
+    }
+
+    function _setHistoryBlockhash(bytes32 blockHash) internal {
+        _setHistoryBlockhash(block.number, blockHash);
+    }
+
+    function _setHistoryBlockhash(uint256 blockNumber, bytes32 blockHash) internal {
+        // Subtracting 1 due to bug encountered during coverage
+        uint256 currentBlock = block.number - 1;
+        vm.assume(blockNumber < type(uint256).max);
+        vm.roll(blockNumber + 1); // roll to the next block so the storage contract sets the parent's blockhash
+        vm.prank(SYSTEM_ADDRESS);
+        (bool success, ) = Blockhash.HISTORY_STORAGE_ADDRESS.call(abi.encode(blockHash)); // set parent's blockhash
+        assertTrue(success);
+        vm.roll(currentBlock + 1);
+    }
+}

package/lib/openzeppelin-contracts/test/utils/Blockhash.test.js

@@ -0,0 +1,59 @@
+const { ethers, predeploy } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture, mineUpTo, setCode } = require('@nomicfoundation/hardhat-network-helpers');
+const { impersonate } = require('../helpers/account');
+
+const SYSTEM_ADDRESS = '0xfffffffffffffffffffffffffffffffffffffffe';
+const HISTORY_SERVE_WINDOW = 8191;
+const BLOCKHASH_SERVE_WINDOW = 256;
+
+async function fixture() {
+  return {
+    mock: await ethers.deployContract('$Blockhash'),
+    systemSigner: await impersonate(SYSTEM_ADDRESS),
+    latestBlock: await ethers.provider.getBlock('latest'),
+  };
+}
+
+describe('Blockhash', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  for (const supported of [true, false]) {
+    describe(`${supported ? 'supported' : 'unsupported'} chain`, function () {
+      beforeEach(async function () {
+        if (supported) {
+          await this.systemSigner.sendTransaction({ to: predeploy.eip2935, data: this.latestBlock.hash });
+        } else {
+          await setCode(predeploy.eip2935.target, '0x');
+        }
+      });
+
+      it('recent block', async function () {
+        // fast forward (less than blockhash serve window)
+        await mineUpTo(this.latestBlock.number + BLOCKHASH_SERVE_WINDOW);
+        await expect(this.mock.$blockHash(this.latestBlock.number)).to.eventually.equal(this.latestBlock.hash);
+      });
+
+      it('old block', async function () {
+        // fast forward (more than blockhash serve window)
+        await mineUpTo(this.latestBlock.number + BLOCKHASH_SERVE_WINDOW + 1);
+        await expect(this.mock.$blockHash(this.latestBlock.number)).to.eventually.equal(
+          supported ? this.latestBlock.hash : ethers.ZeroHash,
+        );
+      });
+
+      it('very old block', async function () {
+        // fast forward (more than history serve window)
+        await mineUpTo(this.latestBlock.number + HISTORY_SERVE_WINDOW + 10);
+        await expect(this.mock.$blockHash(this.latestBlock.number)).to.eventually.equal(ethers.ZeroHash);
+      });
+
+      it('future block', async function () {
+        // check history access in the future
+        await expect(this.mock.$blockHash(this.latestBlock.number + 10)).to.eventually.equal(ethers.ZeroHash);
+      });
+    });
+  }
+});

package/lib/openzeppelin-contracts/test/utils/Bytes.t.sol

@@ -0,0 +1,322 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+import {Test} from "forge-std/Test.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+import {Bytes} from "@openzeppelin/contracts/utils/Bytes.sol";
+
+contract BytesTest is Test {
+    using Bytes for bytes;
+
+    function testSymbolicEqual(bytes memory a) public pure {
+        assertTrue(Bytes.equal(a, a));
+    }
+
+    // INDEX OF
+    function testSymbolicIndexOf(bytes memory buffer, bytes1 s) public pure {
+        uint256 result = Bytes.indexOf(buffer, s);
+
+        if (buffer.length == 0) {
+            // Case 0: buffer is empty
+            assertEq(result, type(uint256).max);
+        } else if (result == type(uint256).max) {
+            // Case 1: search value could not be found
+            for (uint256 i = 0; i < buffer.length; ++i) assertNotEq(buffer[i], s);
+        } else {
+            // Case 2: search value was found
+            assertEq(buffer[result], s);
+            // search value is not present anywhere before the found location
+            for (uint256 i = 0; i < result; ++i) assertNotEq(buffer[i], s);
+        }
+    }
+
+    function testIndexOf(bytes memory buffer, bytes1 s, uint256 pos) public pure {
+        uint256 result = Bytes.indexOf(buffer, s, pos);
+
+        if (buffer.length == 0) {
+            // Case 0: buffer is empty
+            assertEq(result, type(uint256).max);
+        } else if (result == type(uint256).max) {
+            // Case 1: search value could not be found
+            for (uint256 i = pos; i < buffer.length; ++i) assertNotEq(buffer[i], s);
+        } else {
+            // Case 2: search value was found
+            assertEq(buffer[result], s);
+            // search value is not present anywhere before the found location
+            for (uint256 i = pos; i < result; ++i) assertNotEq(buffer[i], s);
+        }
+    }
+
+    function testSymbolicLastIndexOf(bytes memory buffer, bytes1 s) public pure {
+        uint256 result = Bytes.lastIndexOf(buffer, s);
+
+        if (buffer.length == 0) {
+            // Case 0: buffer is empty
+            assertEq(result, type(uint256).max);
+        } else if (result == type(uint256).max) {
+            // Case 1: search value could not be found
+            for (uint256 i = 0; i < buffer.length; ++i) assertNotEq(buffer[i], s);
+        } else {
+            // Case 2: search value was found
+            assertEq(buffer[result], s);
+            // search value is not present anywhere after the found location
+            for (uint256 i = result + 1; i < buffer.length; ++i) assertNotEq(buffer[i], s);
+        }
+    }
+
+    function testLastIndexOf(bytes memory buffer, bytes1 s, uint256 pos) public pure {
+        uint256 result = Bytes.lastIndexOf(buffer, s, pos);
+
+        if (buffer.length == 0) {
+            // Case 0: buffer is empty
+            assertEq(result, type(uint256).max);
+        } else if (result == type(uint256).max) {
+            // Case 1: search value could not be found
+            for (uint256 i = 0; i <= Math.min(pos, buffer.length - 1); ++i) assertNotEq(buffer[i], s);
+        } else {
+            // Case 2: search value was found
+            assertEq(buffer[result], s);
+            // search value is not present anywhere after the found location
+            for (uint256 i = result + 1; i <= Math.min(pos, buffer.length - 1); ++i) assertNotEq(buffer[i], s);
+        }
+    }
+
+    // SLICES
+    function testSliceWithStartOnly(bytes memory buffer, uint256 start) public pure {
+        bytes memory originalBuffer = bytes.concat(buffer);
+        bytes memory result = buffer.slice(start);
+
+        // Original buffer was not modified
+        assertEq(buffer, originalBuffer);
+
+        // Should return bytes from start to end
+        assertEq(result.length, Math.saturatingSub(buffer.length, start));
+
+        // Verify content matches
+        for (uint256 i = 0; i < result.length; ++i) {
+            assertEq(result[i], buffer[start + i]);
+        }
+    }
+
+    function testSlice(bytes memory buffer, uint256 start, uint256 end) public pure {
+        bytes memory originalBuffer = bytes.concat(buffer);
+        bytes memory result = buffer.slice(start, end);
+
+        // Original buffer was not modified
+        assertEq(buffer, originalBuffer);
+
+        // Calculate expected bounds after sanitization
+        uint256 sanitizedEnd = Math.min(end, buffer.length);
+        uint256 sanitizedStart = Math.min(start, sanitizedEnd);
+        uint256 expectedLength = sanitizedEnd - sanitizedStart;
+
+        assertEq(result.length, expectedLength);
+
+        // Verify content matches when there's content to verify
+        for (uint256 i = 0; i < result.length; ++i) {
+            assertEq(result[i], buffer[sanitizedStart + i]);
+        }
+    }
+
+    function testSpliceWithStartOnly(bytes memory buffer, uint256 start) public pure {
+        bytes memory originalBuffer = bytes.concat(buffer);
+        bytes memory result = buffer.splice(start);
+
+        // Result should be the same object as input (modified in place)
+        assertEq(result, buffer);
+
+        // Should contain bytes from start to end, moved to beginning
+        assertEq(result.length, Math.saturatingSub(originalBuffer.length, start));
+
+        // Verify content matches moved content
+        for (uint256 i = 0; i < result.length; ++i) {
+            assertEq(result[i], originalBuffer[start + i]);
+        }
+    }
+
+    function testSplice(bytes memory buffer, uint256 start, uint256 end) public pure {
+        bytes memory originalBuffer = bytes.concat(buffer);
+        bytes memory result = buffer.splice(start, end);
+
+        // Result should be the same object as input (modified in place)
+        assertEq(result, buffer);
+
+        // Calculate expected bounds after sanitization
+        uint256 sanitizedEnd = Math.min(end, originalBuffer.length);
+        uint256 sanitizedStart = Math.min(start, sanitizedEnd);
+        uint256 expectedLength = sanitizedEnd - sanitizedStart;
+
+        assertEq(result.length, expectedLength);
+
+        // Verify content matches moved content
+        for (uint256 i = 0; i < result.length; ++i) {
+            assertEq(result[i], originalBuffer[sanitizedStart + i]);
+        }
+    }
+
+    // Convert to nibbles
+    function testSymbolictoNibbles(bytes memory input) public pure {
+        bytes memory nibbles = Bytes.toNibbles(input);
+        assertEq(nibbles.length, input.length * 2);
+
+        // reconstruct input by traversing nibbles
+        for (uint256 i = 0; i < input.length; ++i) {
+            bytes1 nible0 = nibbles[2 * i];
+            bytes1 nible1 = nibbles[2 * i + 1];
+            assertEq(uint8(nible0) >> 4, 0);
+            assertEq(uint8(nible1) >> 4, 0);
+            assertEq(input[i], bytes1((uint8(nible0) << 4) | uint8(nible1)));
+        }
+    }
+
+    function testReplace(bytes memory buffer, uint256 pos, bytes memory replacement) public pure {
+        bytes memory originalBuffer = bytes.concat(buffer);
+        bytes memory originalReplacement = bytes.concat(replacement);
+        bytes memory result = Bytes.replace(buffer, pos, replacement);
+
+        // Result should be the same object as input (modified in place)
+        assertEq(result, buffer);
+
+        // Buffer length should remain unchanged
+        assertEq(result.length, originalBuffer.length);
+
+        // The replacement is not modified
+        assertEq(replacement, originalReplacement);
+
+        for (uint256 i = 0; i < buffer.length; ++i) {
+            if (i < pos) {
+                assertEq(result[i], originalBuffer[i]);
+            } else if (i < pos + replacement.length) {
+                assertEq(result[i], replacement[i - pos]);
+            } else {
+                assertEq(result[i], originalBuffer[i]);
+            }
+        }
+    }
+
+    function testReplaceFull(
+        bytes memory buffer,
+        uint256 pos,
+        bytes memory replacement,
+        uint256 offset,
+        uint256 length
+    ) public pure {
+        bytes memory originalBuffer = bytes.concat(buffer);
+        bytes memory originalReplacement = bytes.concat(replacement);
+        bytes memory result = Bytes.replace(buffer, pos, replacement, offset, length);
+
+        // Result should be the same object as input (modified in place)
+        assertEq(result, buffer);
+
+        // Buffer length should remain unchanged
+        assertEq(result.length, originalBuffer.length);
+
+        // The replacement is not modified
+        assertEq(replacement, originalReplacement);
+
+        for (uint256 i = 0; i < buffer.length; ++i) {
+            if (i < pos) {
+                assertEq(result[i], originalBuffer[i]);
+            } else if (i < pos + Math.min(Math.saturatingSub(replacement.length, offset), length)) {
+                assertEq(result[i], replacement[i - pos + offset]);
+            } else {
+                assertEq(result[i], originalBuffer[i]);
+            }
+        }
+    }
+
+    // REVERSE BITS
+    function testSymbolicReverseBytes32(bytes32 value) public pure {
+        assertEq(Bytes.reverseBytes32(Bytes.reverseBytes32(value)), value);
+    }
+
+    function testSymbolicReverseBytes16(bytes16 value) public pure {
+        assertEq(Bytes.reverseBytes16(Bytes.reverseBytes16(value)), value);
+    }
+
+    function testSymbolicReverseBytes16Dirty(bytes16 value) public pure {
+        assertEq(Bytes.reverseBytes16(Bytes.reverseBytes16(_dirtyBytes16(value))), value);
+        assertEq(Bytes.reverseBytes16(_dirtyBytes16(Bytes.reverseBytes16(value))), value);
+    }
+
+    function testSymbolicReverseBytes8(bytes8 value) public pure {
+        assertEq(Bytes.reverseBytes8(Bytes.reverseBytes8(value)), value);
+    }
+
+    function testSymbolicReverseBytes8Dirty(bytes8 value) public pure {
+        assertEq(Bytes.reverseBytes8(Bytes.reverseBytes8(_dirtyBytes8(value))), value);
+        assertEq(Bytes.reverseBytes8(_dirtyBytes8(Bytes.reverseBytes8(value))), value);
+    }
+
+    function testSymbolicReverseBytes4(bytes4 value) public pure {
+        assertEq(Bytes.reverseBytes4(Bytes.reverseBytes4(value)), value);
+    }
+
+    function testSymbolicReverseBytes4Dirty(bytes4 value) public pure {
+        assertEq(Bytes.reverseBytes4(Bytes.reverseBytes4(_dirtyBytes4(value))), value);
+        assertEq(Bytes.reverseBytes4(_dirtyBytes4(Bytes.reverseBytes4(value))), value);
+    }
+
+    function testSymbolicReverseBytes2(bytes2 value) public pure {
+        assertEq(Bytes.reverseBytes2(Bytes.reverseBytes2(value)), value);
+    }
+
+    function testSymbolicReverseBytes2Dirty(bytes2 value) public pure {
+        assertEq(Bytes.reverseBytes2(Bytes.reverseBytes2(_dirtyBytes2(value))), value);
+        assertEq(Bytes.reverseBytes2(_dirtyBytes2(Bytes.reverseBytes2(value))), value);
+    }
+
+    // CLZ (Count Leading Zeros)
+    function testClz(bytes memory buffer) public pure {
+        uint256 result = Bytes.clz(buffer);
+
+        // index and offset of the first non zero bit
+        uint256 index = result / 8;
+        uint256 offset = result % 8;
+
+        // Result should never exceed buffer length
+        assertLe(index, buffer.length);
+
+        // All bytes before index position must be zero
+        for (uint256 i = 0; i < index; ++i) {
+            assertEq(buffer[i], 0);
+        }
+
+        // If index < buffer.length, byte at index position must be non-zero
+        if (index < buffer.length) {
+            // bit at position offset must be non zero
+            bytes1 singleBitMask = bytes1(0x80) >> offset;
+            assertEq(buffer[index] & singleBitMask, singleBitMask);
+
+            // all bits before offset must be zero
+            bytes1 multiBitsMask = bytes1(0xff) << (8 - offset);
+            assertEq(buffer[index] & multiBitsMask, 0);
+        }
+    }
+
+    // Helpers
+    function _dirtyBytes16(bytes16 value) private pure returns (bytes16 dirty) {
+        assembly ("memory-safe") {
+            dirty := or(value, shr(128, not(0)))
+        }
+    }
+
+    function _dirtyBytes8(bytes8 value) private pure returns (bytes8 dirty) {
+        assembly ("memory-safe") {
+            dirty := or(value, shr(192, not(0)))
+        }
+    }
+
+    function _dirtyBytes4(bytes4 value) private pure returns (bytes4 dirty) {
+        assembly ("memory-safe") {
+            dirty := or(value, shr(224, not(0)))
+        }
+    }
+
+    function _dirtyBytes2(bytes2 value) private pure returns (bytes2 dirty) {
+        assembly ("memory-safe") {
+            dirty := or(value, shr(240, not(0)))
+        }
+    }
+}