@elizaos/autonomous 2.0.0-alpha.21 → 2.0.0-alpha.22

package/test/contracts/lib/openzeppelin-contracts/lib/forge-std/test/StdChains.t.sol

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.7.0 <0.9.0;
+
+import "../src/Test.sol";
+
+contract StdChainsTest is Test {
+    function testChainRpcInitialization() public {
+        // RPCs specified in `foundry.toml` should be updated.
+        assertEq(getChain(1).rpcUrl, "https://mainnet.infura.io/v3/16a8be88795540b9b3903d8de0f7baa5");
+        assertEq(getChain("optimism_goerli").rpcUrl, "https://goerli.optimism.io/");
+        assertEq(getChain("arbitrum_one_goerli").rpcUrl, "https://goerli-rollup.arbitrum.io/rpc/");
+
+        // Environment variables should be the next fallback
+        assertEq(getChain("arbitrum_nova").rpcUrl, "https://nova.arbitrum.io/rpc");
+        vm.setEnv("ARBITRUM_NOVA_RPC_URL", "myoverride");
+        assertEq(getChain("arbitrum_nova").rpcUrl, "myoverride");
+        vm.setEnv("ARBITRUM_NOVA_RPC_URL", "https://nova.arbitrum.io/rpc");
+
+        // Cannot override RPCs defined in `foundry.toml`
+        vm.setEnv("MAINNET_RPC_URL", "myoverride2");
+        assertEq(getChain("mainnet").rpcUrl, "https://mainnet.infura.io/v3/16a8be88795540b9b3903d8de0f7baa5");
+
+        // Other RPCs should remain unchanged.
+        assertEq(getChain(31337).rpcUrl, "http://127.0.0.1:8545");
+        assertEq(getChain("sepolia").rpcUrl, "https://sepolia.infura.io/v3/f4a0bdad42674adab5fc0ac077ffab2b");
+    }
+
+    function testRpc(string memory rpcAlias) internal {
+        string memory rpcUrl = getChain(rpcAlias).rpcUrl;
+        vm.createSelectFork(rpcUrl);
+    }
+
+    // Ensure we can connect to the default RPC URL for each chain.
+    function testRpcs() public {
+        testRpc("mainnet");
+        testRpc("goerli");
+        testRpc("sepolia");
+        testRpc("optimism");
+        testRpc("optimism_goerli");
+        testRpc("arbitrum_one");
+        testRpc("arbitrum_one_goerli");
+        testRpc("arbitrum_nova");
+        testRpc("polygon");
+        testRpc("polygon_mumbai");
+        testRpc("avalanche");
+        testRpc("avalanche_fuji");
+        testRpc("bnb_smart_chain");
+        testRpc("bnb_smart_chain_testnet");
+        testRpc("gnosis_chain");
+    }
+
+    function testChainNoDefault() public {
+        vm.expectRevert("StdChains getChain(string): Chain with alias \"does_not_exist\" not found.");
+        getChain("does_not_exist");
+    }
+
+    function testSetChainFirstFails() public {
+        vm.expectRevert("StdChains setChain(string,ChainData): Chain ID 31337 already used by \"anvil\".");
+        setChain("anvil2", ChainData("Anvil", 31337, "URL"));
+    }
+
+    function testChainBubbleUp() public {
+        setChain("needs_undefined_env_var", ChainData("", 123456789, ""));
+        vm.expectRevert(
+            "Failed to resolve env var `UNDEFINED_RPC_URL_PLACEHOLDER` in `${UNDEFINED_RPC_URL_PLACEHOLDER}`: environment variable not found"
+        );
+        getChain("needs_undefined_env_var");
+    }
+
+    function testCannotSetChain_ChainIdExists() public {
+        setChain("custom_chain", ChainData("Custom Chain", 123456789, "https://custom.chain/"));
+
+        vm.expectRevert('StdChains setChain(string,ChainData): Chain ID 123456789 already used by "custom_chain".');
+
+        setChain("another_custom_chain", ChainData("", 123456789, ""));
+    }
+
+    function testSetChain() public {
+        setChain("custom_chain", ChainData("Custom Chain", 123456789, "https://custom.chain/"));
+        Chain memory customChain = getChain("custom_chain");
+        assertEq(customChain.name, "Custom Chain");
+        assertEq(customChain.chainId, 123456789);
+        assertEq(customChain.chainAlias, "custom_chain");
+        assertEq(customChain.rpcUrl, "https://custom.chain/");
+        Chain memory chainById = getChain(123456789);
+        assertEq(chainById.name, customChain.name);
+        assertEq(chainById.chainId, customChain.chainId);
+        assertEq(chainById.chainAlias, customChain.chainAlias);
+        assertEq(chainById.rpcUrl, customChain.rpcUrl);
+        customChain.name = "Another Custom Chain";
+        customChain.chainId = 987654321;
+        setChain("another_custom_chain", customChain);
+        Chain memory anotherCustomChain = getChain("another_custom_chain");
+        assertEq(anotherCustomChain.name, "Another Custom Chain");
+        assertEq(anotherCustomChain.chainId, 987654321);
+        assertEq(anotherCustomChain.chainAlias, "another_custom_chain");
+        assertEq(anotherCustomChain.rpcUrl, "https://custom.chain/");
+        // Verify the first chain data was not overwritten
+        chainById = getChain(123456789);
+        assertEq(chainById.name, "Custom Chain");
+        assertEq(chainById.chainId, 123456789);
+    }
+
+    function testSetNoEmptyAlias() public {
+        vm.expectRevert("StdChains setChain(string,ChainData): Chain alias cannot be the empty string.");
+        setChain("", ChainData("", 123456789, ""));
+    }
+
+    function testSetNoChainId0() public {
+        vm.expectRevert("StdChains setChain(string,ChainData): Chain ID cannot be 0.");
+        setChain("alias", ChainData("", 0, ""));
+    }
+
+    function testGetNoChainId0() public {
+        vm.expectRevert("StdChains getChain(uint256): Chain ID cannot be 0.");
+        getChain(0);
+    }
+
+    function testGetNoEmptyAlias() public {
+        vm.expectRevert("StdChains getChain(string): Chain alias cannot be the empty string.");
+        getChain("");
+    }
+
+    function testChainIdNotFound() public {
+        vm.expectRevert("StdChains getChain(string): Chain with alias \"no_such_alias\" not found.");
+        getChain("no_such_alias");
+    }
+
+    function testChainAliasNotFound() public {
+        vm.expectRevert("StdChains getChain(uint256): Chain with ID 321 not found.");
+        getChain(321);
+    }
+
+    function testSetChain_ExistingOne() public {
+        setChain("custom_chain", ChainData("Custom Chain", 123456789, "https://custom.chain/"));
+        assertEq(getChain(123456789).chainId, 123456789);
+
+        setChain("custom_chain", ChainData("Modified Chain", 999999999, "https://modified.chain/"));
+        vm.expectRevert("StdChains getChain(uint256): Chain with ID 123456789 not found.");
+        getChain(123456789);
+
+        Chain memory modifiedChain = getChain(999999999);
+        assertEq(modifiedChain.name, "Modified Chain");
+        assertEq(modifiedChain.chainId, 999999999);
+        assertEq(modifiedChain.rpcUrl, "https://modified.chain/");
+    }
+
+    function testDontUseDefaultRpcUrl() public {
+        // Should error if default RPCs flag is set to false.
+        setFallbackToDefaultRpcUrls(false);
+        vm.expectRevert(
+            "Failed to get environment variable `ANVIL_RPC_URL` as type `string`: environment variable not found"
+        );
+        getChain(31337);
+        vm.expectRevert(
+            "Failed to get environment variable `SEPOLIA_RPC_URL` as type `string`: environment variable not found"
+        );
+        getChain("sepolia");
+    }
+}

package/test/contracts/lib/openzeppelin-contracts/lib/forge-std/test/StdCheats.t.sol

@@ -0,0 +1,401 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.7.0 <0.9.0;
+
+import "../src/StdCheats.sol";
+import "../src/Test.sol";
+import "../src/StdJson.sol";
+
+contract StdCheatsTest is Test {
+    Bar test;
+
+    using stdJson for string;
+
+    function setUp() public {
+        test = new Bar();
+    }
+
+    function testSkip() public {
+        vm.warp(100);
+        skip(25);
+        assertEq(block.timestamp, 125);
+    }
+
+    function testRewind() public {
+        vm.warp(100);
+        rewind(25);
+        assertEq(block.timestamp, 75);
+    }
+
+    function testHoax() public {
+        hoax(address(1337));
+        test.bar{value: 100}(address(1337));
+    }
+
+    function testHoaxOrigin() public {
+        hoax(address(1337), address(1337));
+        test.origin{value: 100}(address(1337));
+    }
+
+    function testHoaxDifferentAddresses() public {
+        hoax(address(1337), address(7331));
+        test.origin{value: 100}(address(1337), address(7331));
+    }
+
+    function testStartHoax() public {
+        startHoax(address(1337));
+        test.bar{value: 100}(address(1337));
+        test.bar{value: 100}(address(1337));
+        vm.stopPrank();
+        test.bar(address(this));
+    }
+
+    function testStartHoaxOrigin() public {
+        startHoax(address(1337), address(1337));
+        test.origin{value: 100}(address(1337));
+        test.origin{value: 100}(address(1337));
+        vm.stopPrank();
+        test.bar(address(this));
+    }
+
+    function testChangePrank() public {
+        vm.startPrank(address(1337));
+        test.bar(address(1337));
+        changePrank(address(0xdead));
+        test.bar(address(0xdead));
+        changePrank(address(1337));
+        test.bar(address(1337));
+        vm.stopPrank();
+    }
+
+    function testMakeAddrEquivalence() public {
+        (address addr,) = makeAddrAndKey("1337");
+        assertEq(makeAddr("1337"), addr);
+    }
+
+    function testMakeAddrSigning() public {
+        (address addr, uint256 key) = makeAddrAndKey("1337");
+        bytes32 hash = keccak256("some_message");
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(key, hash);
+        assertEq(ecrecover(hash, v, r, s), addr);
+    }
+
+    function testDeal() public {
+        deal(address(this), 1 ether);
+        assertEq(address(this).balance, 1 ether);
+    }
+
+    function testDealToken() public {
+        Bar barToken = new Bar();
+        address bar = address(barToken);
+        deal(bar, address(this), 10000e18);
+        assertEq(barToken.balanceOf(address(this)), 10000e18);
+    }
+
+    function testDealTokenAdjustTotalSupply() public {
+        Bar barToken = new Bar();
+        address bar = address(barToken);
+        deal(bar, address(this), 10000e18, true);
+        assertEq(barToken.balanceOf(address(this)), 10000e18);
+        assertEq(barToken.totalSupply(), 20000e18);
+        deal(bar, address(this), 0, true);
+        assertEq(barToken.balanceOf(address(this)), 0);
+        assertEq(barToken.totalSupply(), 10000e18);
+    }
+
+    function testDealERC1155Token() public {
+        BarERC1155 barToken = new BarERC1155();
+        address bar = address(barToken);
+        dealERC1155(bar, address(this), 0, 10000e18, false);
+        assertEq(barToken.balanceOf(address(this), 0), 10000e18);
+    }
+
+    function testDealERC1155TokenAdjustTotalSupply() public {
+        BarERC1155 barToken = new BarERC1155();
+        address bar = address(barToken);
+        dealERC1155(bar, address(this), 0, 10000e18, true);
+        assertEq(barToken.balanceOf(address(this), 0), 10000e18);
+        assertEq(barToken.totalSupply(0), 20000e18);
+        dealERC1155(bar, address(this), 0, 0, true);
+        assertEq(barToken.balanceOf(address(this), 0), 0);
+        assertEq(barToken.totalSupply(0), 10000e18);
+    }
+
+    function testDealERC721Token() public {
+        BarERC721 barToken = new BarERC721();
+        address bar = address(barToken);
+        dealERC721(bar, address(2), 1);
+        assertEq(barToken.balanceOf(address(2)), 1);
+        assertEq(barToken.balanceOf(address(1)), 0);
+        dealERC721(bar, address(1), 2);
+        assertEq(barToken.balanceOf(address(1)), 1);
+        assertEq(barToken.balanceOf(bar), 1);
+    }
+
+    function testDeployCode() public {
+        address deployed = deployCode("StdCheats.t.sol:Bar", bytes(""));
+        assertEq(string(getCode(deployed)), string(getCode(address(test))));
+    }
+
+    function testDeployCodeNoArgs() public {
+        address deployed = deployCode("StdCheats.t.sol:Bar");
+        assertEq(string(getCode(deployed)), string(getCode(address(test))));
+    }
+
+    function testDeployCodeVal() public {
+        address deployed = deployCode("StdCheats.t.sol:Bar", bytes(""), 1 ether);
+        assertEq(string(getCode(deployed)), string(getCode(address(test))));
+        assertEq(deployed.balance, 1 ether);
+    }
+
+    function testDeployCodeValNoArgs() public {
+        address deployed = deployCode("StdCheats.t.sol:Bar", 1 ether);
+        assertEq(string(getCode(deployed)), string(getCode(address(test))));
+        assertEq(deployed.balance, 1 ether);
+    }
+
+    // We need this so we can call "this.deployCode" rather than "deployCode" directly
+    function deployCodeHelper(string memory what) external {
+        deployCode(what);
+    }
+
+    function testDeployCodeFail() public {
+        vm.expectRevert(bytes("StdCheats deployCode(string): Deployment failed."));
+        this.deployCodeHelper("StdCheats.t.sol:RevertingContract");
+    }
+
+    function getCode(address who) internal view returns (bytes memory o_code) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            // retrieve the size of the code, this needs assembly
+            let size := extcodesize(who)
+            // allocate output byte array - this could also be done without assembly
+            // by using o_code = new bytes(size)
+            o_code := mload(0x40)
+            // new "memory end" including padding
+            mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f))))
+            // store length in memory
+            mstore(o_code, size)
+            // actually retrieve the code, this needs assembly
+            extcodecopy(who, add(o_code, 0x20), 0, size)
+        }
+    }
+
+    function testDeriveRememberKey() public {
+        string memory mnemonic = "test test test test test test test test test test test junk";
+
+        (address deployer, uint256 privateKey) = deriveRememberKey(mnemonic, 0);
+        assertEq(deployer, 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266);
+        assertEq(privateKey, 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80);
+    }
+
+    function testBytesToUint() public {
+        assertEq(3, bytesToUint_test(hex"03"));
+        assertEq(2, bytesToUint_test(hex"02"));
+        assertEq(255, bytesToUint_test(hex"ff"));
+        assertEq(29625, bytesToUint_test(hex"73b9"));
+    }
+
+    function testParseJsonTxDetail() public {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/test/fixtures/broadcast.log.json");
+        string memory json = vm.readFile(path);
+        bytes memory transactionDetails = json.parseRaw(".transactions[0].tx");
+        RawTx1559Detail memory rawTxDetail = abi.decode(transactionDetails, (RawTx1559Detail));
+        Tx1559Detail memory txDetail = rawToConvertedEIP1559Detail(rawTxDetail);
+        assertEq(txDetail.from, 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266);
+        assertEq(txDetail.to, 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512);
+        assertEq(
+            txDetail.data,
+            hex"23e99187000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000013370000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000004"
+        );
+        assertEq(txDetail.nonce, 3);
+        assertEq(txDetail.txType, 2);
+        assertEq(txDetail.gas, 29625);
+        assertEq(txDetail.value, 0);
+    }
+
+    function testReadEIP1559Transaction() public view {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/test/fixtures/broadcast.log.json");
+        uint256 index = 0;
+        Tx1559 memory transaction = readTx1559(path, index);
+        transaction;
+    }
+
+    function testReadEIP1559Transactions() public view {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/test/fixtures/broadcast.log.json");
+        Tx1559[] memory transactions = readTx1559s(path);
+        transactions;
+    }
+
+    function testReadReceipt() public {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/test/fixtures/broadcast.log.json");
+        uint256 index = 5;
+        Receipt memory receipt = readReceipt(path, index);
+        assertEq(
+            receipt.logsBloom,
+            hex"00000000000800000000000000000010000000000000000000000000000180000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100"
+        );
+    }
+
+    function testReadReceipts() public view {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/test/fixtures/broadcast.log.json");
+        Receipt[] memory receipts = readReceipts(path);
+        receipts;
+    }
+
+    function testGasMeteringModifier() public {
+        uint256 gas_start_normal = gasleft();
+        addInLoop();
+        uint256 gas_used_normal = gas_start_normal - gasleft();
+
+        uint256 gas_start_single = gasleft();
+        addInLoopNoGas();
+        uint256 gas_used_single = gas_start_single - gasleft();
+
+        uint256 gas_start_double = gasleft();
+        addInLoopNoGasNoGas();
+        uint256 gas_used_double = gas_start_double - gasleft();
+
+        emit log_named_uint("Normal gas", gas_used_normal);
+        emit log_named_uint("Single modifier gas", gas_used_single);
+        emit log_named_uint("Double modifier  gas", gas_used_double);
+        assertTrue(gas_used_double + gas_used_single < gas_used_normal);
+    }
+
+    function addInLoop() internal pure returns (uint256) {
+        uint256 b;
+        for (uint256 i; i < 10000; i++) {
+            b += i;
+        }
+        return b;
+    }
+
+    function addInLoopNoGas() internal noGasMetering returns (uint256) {
+        return addInLoop();
+    }
+
+    function addInLoopNoGasNoGas() internal noGasMetering returns (uint256) {
+        return addInLoopNoGas();
+    }
+
+    function bytesToUint_test(bytes memory b) private pure returns (uint256) {
+        uint256 number;
+        for (uint256 i = 0; i < b.length; i++) {
+            number = number + uint256(uint8(b[i])) * (2 ** (8 * (b.length - (i + 1))));
+        }
+        return number;
+    }
+
+    function testAssumeNoPrecompiles(address addr) external {
+        assumeNoPrecompiles(addr, getChain("optimism_goerli").chainId);
+        assertTrue(
+            addr < address(1) || (addr > address(9) && addr < address(0x4200000000000000000000000000000000000000))
+                || addr > address(0x4200000000000000000000000000000000000800)
+        );
+    }
+
+    function testAssumePayable() external {
+        // all should revert since these addresses are not payable
+
+        // VM address
+        vm.expectRevert();
+        assumePayable(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
+
+        // Console address
+        vm.expectRevert();
+        assumePayable(0x000000000000000000636F6e736F6c652e6c6f67);
+
+        // Create2Deployer
+        vm.expectRevert();
+        assumePayable(0x4e59b44847b379578588920cA78FbF26c0B4956C);
+    }
+
+    function testAssumePayable(address addr) external {
+        assumePayable(addr);
+        assertTrue(
+            addr != 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D && addr != 0x000000000000000000636F6e736F6c652e6c6f67
+                && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C
+        );
+    }
+}
+
+contract Bar {
+    constructor() payable {
+        /// `DEAL` STDCHEAT
+        totalSupply = 10000e18;
+        balanceOf[address(this)] = totalSupply;
+    }
+
+    /// `HOAX` STDCHEATS
+    function bar(address expectedSender) public payable {
+        require(msg.sender == expectedSender, "!prank");
+    }
+
+    function origin(address expectedSender) public payable {
+        require(msg.sender == expectedSender, "!prank");
+        require(tx.origin == expectedSender, "!prank");
+    }
+
+    function origin(address expectedSender, address expectedOrigin) public payable {
+        require(msg.sender == expectedSender, "!prank");
+        require(tx.origin == expectedOrigin, "!prank");
+    }
+
+    /// `DEAL` STDCHEAT
+    mapping(address => uint256) public balanceOf;
+    uint256 public totalSupply;
+}
+
+contract BarERC1155 {
+    constructor() payable {
+        /// `DEALERC1155` STDCHEAT
+        _totalSupply[0] = 10000e18;
+        _balances[0][address(this)] = _totalSupply[0];
+    }
+
+    function balanceOf(address account, uint256 id) public view virtual returns (uint256) {
+        return _balances[id][account];
+    }
+
+    function totalSupply(uint256 id) public view virtual returns (uint256) {
+        return _totalSupply[id];
+    }
+
+    /// `DEALERC1155` STDCHEAT
+    mapping(uint256 => mapping(address => uint256)) private _balances;
+    mapping(uint256 => uint256) private _totalSupply;
+}
+
+contract BarERC721 {
+    constructor() payable {
+        /// `DEALERC721` STDCHEAT
+        _owners[1] = address(1);
+        _balances[address(1)] = 1;
+        _owners[2] = address(this);
+        _owners[3] = address(this);
+        _balances[address(this)] = 2;
+    }
+
+    function balanceOf(address owner) public view virtual returns (uint256) {
+        return _balances[owner];
+    }
+
+    function ownerOf(uint256 tokenId) public view virtual returns (address) {
+        address owner = _owners[tokenId];
+        return owner;
+    }
+
+    mapping(uint256 => address) private _owners;
+    mapping(address => uint256) private _balances;
+}
+
+contract RevertingContract {
+    constructor() {
+        revert();
+    }
+}

package/test/contracts/lib/openzeppelin-contracts/lib/forge-std/test/StdError.t.sol

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0 <0.9.0;
+
+import "../src/StdError.sol";
+import "../src/Test.sol";
+
+contract StdErrorsTest is Test {
+    ErrorsTest test;
+
+    function setUp() public {
+        test = new ErrorsTest();
+    }
+
+    function testExpectAssertion() public {
+        vm.expectRevert(stdError.assertionError);
+        test.assertionError();
+    }
+
+    function testExpectArithmetic() public {
+        vm.expectRevert(stdError.arithmeticError);
+        test.arithmeticError(10);
+    }
+
+    function testExpectDiv() public {
+        vm.expectRevert(stdError.divisionError);
+        test.divError(0);
+    }
+
+    function testExpectMod() public {
+        vm.expectRevert(stdError.divisionError);
+        test.modError(0);
+    }
+
+    function testExpectEnum() public {
+        vm.expectRevert(stdError.enumConversionError);
+        test.enumConversion(1);
+    }
+
+    function testExpectEncodeStg() public {
+        vm.expectRevert(stdError.encodeStorageError);
+        test.encodeStgError();
+    }
+
+    function testExpectPop() public {
+        vm.expectRevert(stdError.popError);
+        test.pop();
+    }
+
+    function testExpectOOB() public {
+        vm.expectRevert(stdError.indexOOBError);
+        test.indexOOBError(1);
+    }
+
+    function testExpectMem() public {
+        vm.expectRevert(stdError.memOverflowError);
+        test.mem();
+    }
+
+    function testExpectIntern() public {
+        vm.expectRevert(stdError.zeroVarError);
+        test.intern();
+    }
+}
+
+contract ErrorsTest {
+    enum T {T1}
+
+    uint256[] public someArr;
+    bytes someBytes;
+
+    function assertionError() public pure {
+        assert(false);
+    }
+
+    function arithmeticError(uint256 a) public pure {
+        a -= 100;
+    }
+
+    function divError(uint256 a) public pure {
+        100 / a;
+    }
+
+    function modError(uint256 a) public pure {
+        100 % a;
+    }
+
+    function enumConversion(uint256 a) public pure {
+        T(a);
+    }
+
+    function encodeStgError() public {
+        /// @solidity memory-safe-assembly
+        assembly {
+            sstore(someBytes.slot, 1)
+        }
+        keccak256(someBytes);
+    }
+
+    function pop() public {
+        someArr.pop();
+    }
+
+    function indexOOBError(uint256 a) public pure {
+        uint256[] memory t = new uint256[](0);
+        t[a];
+    }
+
+    function mem() public pure {
+        uint256 l = 2 ** 256 / 32;
+        new uint256[](l);
+    }
+
+    function intern() public returns (uint256) {
+        function(uint256) internal returns (uint256) x;
+        x(2);
+        return 7;
+    }
+}