Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-08-26
*/

// File: contracts/libs/SSTORE2.sol


pragma solidity ^0.8.4;

/// @notice Read and write to persistent storage at a fraction of the cost.
/// @author Solady (https://github.com/vectorized/solmady/blob/main/src/utils/SSTORE2.sol)
/// @author Saw-mon-and-Natalie (https://github.com/Saw-mon-and-Natalie)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SSTORE2.sol)
/// @author Modified from 0xSequence (https://github.com/0xSequence/sstore2/blob/master/contracts/SSTORE2.sol)
library SSTORE2 {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev We skip the first byte as it's a STOP opcode,
    /// which ensures the contract can't be called.
    uint256 internal constant DATA_OFFSET = 1;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                        CUSTOM ERRORS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Unable to deploy the storage contract.
    error DeploymentFailed();

    /// @dev The storage contract address is invalid.
    error InvalidPointer();

    /// @dev Attempt to read outside of the storage contract's bytecode bounds.
    error ReadOutOfBounds();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         WRITE LOGIC                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Writes `data` into the bytecode of a storage contract and returns its address.
    function write(bytes memory data) internal returns (address pointer) {
        /// @solidity memory-safe-assembly
        assembly {
            let originalDataLength := mload(data)

            // Add 1 to data size since we are prefixing it with a STOP opcode.
            let dataSize := add(originalDataLength, DATA_OFFSET)

            /**
             * ------------------------------------------------------------------------------+
             * Opcode      | Mnemonic        | Stack                   | Memory              |
             * ------------------------------------------------------------------------------|
             * 61 codeSize | PUSH2 codeSize  | codeSize                |                     |
             * 80          | DUP1            | codeSize codeSize       |                     |
             * 60 0xa      | PUSH1 0xa       | 0xa codeSize codeSize   |                     |
             * 3D          | RETURNDATASIZE  | 0 0xa codeSize codeSize |                     |
             * 39          | CODECOPY        | codeSize                | [0..codeSize): code |
             * 3D          | RETURNDATASZIE  | 0 codeSize              | [0..codeSize): code |
             * F3          | RETURN          |                         | [0..codeSize): code |
             * 00          | STOP            |                         |                     |
             * ------------------------------------------------------------------------------+
             * @dev Prefix the bytecode with a STOP opcode to ensure it cannot be called.
             * Also PUSH2 is used since max contract size cap is 24,576 bytes which is less than 2 ** 16.
             */
            mstore(
                data,
                or(
                    0x61000080600a3d393df300,
                    // Left shift `dataSize` by 64 so that it lines up with the 0000 after PUSH2.
                    shl(0x40, dataSize)
                )
            )

            // Deploy a new contract with the generated creation code.
            pointer := create(0, add(data, 0x15), add(dataSize, 0xa))

            // If `pointer` is zero, revert.
            if iszero(pointer) {
                // Store the function selector of `DeploymentFailed()`.
                mstore(0x00, 0x30116425)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // Restore original length of the variable size `data`.
            mstore(data, originalDataLength)
        }
    }

    /// @dev Writes `data` into the bytecode of a storage contract with `salt`
    /// and returns its deterministic address.
    function writeDeterministic(bytes memory data, bytes32 salt)
        internal
        returns (address pointer)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let originalDataLength := mload(data)
            let dataSize := add(originalDataLength, DATA_OFFSET)

            mstore(data, or(0x61000080600a3d393df300, shl(0x40, dataSize)))

            // Deploy a new contract with the generated creation code.
            pointer := create2(0, add(data, 0x15), add(dataSize, 0xa), salt)

            // If `pointer` is zero, revert.
            if iszero(pointer) {
                // Store the function selector of `DeploymentFailed()`.
                mstore(0x00, 0x30116425)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // Restore original length of the variable size `data`.
            mstore(data, originalDataLength)
        }
    }

    /// @dev Returns the initialization code hash of the storage contract for `data`.
    /// Used for mining vanity addresses with create2crunch.
    function initCodeHash(bytes memory data) internal pure returns (bytes32 hash) {
        /// @solidity memory-safe-assembly
        assembly {
            let originalDataLength := mload(data)
            let dataSize := add(originalDataLength, DATA_OFFSET)

            mstore(data, or(0x61000080600a3d393df300, shl(0x40, dataSize)))

            hash := keccak256(add(data, 0x15), add(dataSize, 0xa))

            // Restore original length of the variable size `data`.
            mstore(data, originalDataLength)
        }
    }

    /// @dev Returns the address of the storage contract for `data`
    /// deployed with `salt` by `deployer`.
    function predictDeterministicAddress(bytes memory data, bytes32 salt, address deployer)
        internal
        pure
        returns (address predicted)
    {
        bytes32 hash = initCodeHash(data);
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and store the bytecode hash.
            mstore8(0x00, 0xff) // Write the prefix.
            mstore(0x35, hash)
            mstore(0x01, shl(96, deployer))
            mstore(0x15, salt)
            predicted := keccak256(0x00, 0x55)
            // Restore the part of the free memory pointer that has been overwritten.
            mstore(0x35, 0)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         READ LOGIC                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns all the `data` from the bytecode of the storage contract at `pointer`.
    function read(address pointer) internal view returns (bytes memory data) {
        /// @solidity memory-safe-assembly
        assembly {
            let pointerCodesize := extcodesize(pointer)
            if iszero(pointerCodesize) {
                // Store the function selector of `InvalidPointer()`.
                mstore(0x00, 0x11052bb4)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Offset all indices by 1 to skip the STOP opcode.
            let size := sub(pointerCodesize, DATA_OFFSET)

            // Get the pointer to the free memory and allocate
            // enough 32-byte words for the data and the length of the data,
            // then copy the code to the allocated memory.
            // Masking with 0xffe0 will suffice, since contract size is less than 16 bits.
            data := mload(0x40)
            mstore(0x40, add(data, and(add(size, 0x3f), 0xffe0)))
            mstore(data, size)
            mstore(add(add(data, 0x20), size), 0) // Zeroize the last slot.
            extcodecopy(pointer, add(data, 0x20), DATA_OFFSET, size)
        }
    }

    /// @dev Returns the `data` from the bytecode of the storage contract at `pointer`,
    /// from the byte at `start`, to the end of the data stored.
    function read(address pointer, uint256 start) internal view returns (bytes memory data) {
        /// @solidity memory-safe-assembly
        assembly {
            let pointerCodesize := extcodesize(pointer)
            if iszero(pointerCodesize) {
                // Store the function selector of `InvalidPointer()`.
                mstore(0x00, 0x11052bb4)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // If `!(pointer.code.size > start)`, reverts.
            // This also handles the case where `start + DATA_OFFSET` overflows.
            if iszero(gt(pointerCodesize, start)) {
                // Store the function selector of `ReadOutOfBounds()`.
                mstore(0x00, 0x84eb0dd1)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            let size := sub(pointerCodesize, add(start, DATA_OFFSET))

            // Get the pointer to the free memory and allocate
            // enough 32-byte words for the data and the length of the data,
            // then copy the code to the allocated memory.
            // Masking with 0xffe0 will suffice, since contract size is less than 16 bits.
            data := mload(0x40)
            mstore(0x40, add(data, and(add(size, 0x3f), 0xffe0)))
            mstore(data, size)
            mstore(add(add(data, 0x20), size), 0) // Zeroize the last slot.
            extcodecopy(pointer, add(data, 0x20), add(start, DATA_OFFSET), size)
        }
    }

    /// @dev Returns the `data` from the bytecode of the storage contract at `pointer`,
    /// from the byte at `start`, to the byte at `end` (exclusive) of the data stored.
    function read(address pointer, uint256 start, uint256 end)
        internal
        view
        returns (bytes memory data)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let pointerCodesize := extcodesize(pointer)
            if iszero(pointerCodesize) {
                // Store the function selector of `InvalidPointer()`.
                mstore(0x00, 0x11052bb4)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // If `!(pointer.code.size > end) || (start > end)`, revert.
            // This also handles the cases where
            // `end + DATA_OFFSET` or `start + DATA_OFFSET` overflows.
            if iszero(
                and(
                    gt(pointerCodesize, end), // Within bounds.
                    iszero(gt(start, end)) // Valid range.
                )
            ) {
                // Store the function selector of `ReadOutOfBounds()`.
                mstore(0x00, 0x84eb0dd1)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            let size := sub(end, start)

            // Get the pointer to the free memory and allocate
            // enough 32-byte words for the data and the length of the data,
            // then copy the code to the allocated memory.
            // Masking with 0xffe0 will suffice, since contract size is less than 16 bits.
            data := mload(0x40)
            mstore(0x40, add(data, and(add(size, 0x3f), 0xffe0)))
            mstore(data, size)
            mstore(add(add(data, 0x20), size), 0) // Zeroize the last slot.
            extcodecopy(pointer, add(data, 0x20), add(start, DATA_OFFSET), size)
        }
    }
}
// File: contracts/Shredder.sol


pragma solidity ^0.8.21;


contract Shredder {
    address constant private chunk1 = 0x3A5aB14A5E527a664357343AC0458e088905BF1f;
    address constant private chunk2 = 0x589B2Bec0d099B6Bb538D6aF689b43D1327f0C5F;
    address constant private chunk3 = 0x7BeB62fe90BfDef27DA7d7E136dED3c332387021;
    address constant private chunk4 = 0xa42E29F2a60F60da5183483651807db7623904D5;
    address constant private chunk5 = 0x19b52748E51483ddcfC0F5BDC0E592022BcBFB82;
    uint256 constant private chunkLength = 22730;
    bytes1 constant private darkness = 0x30;
    bytes1 constant private light = 0x31;

    bool private _mode;
    bool[] private modeHistory;
    uint256 public shredCounter;

    function read() external view returns (string memory) {
        bytes memory original = bytes.concat(
            SSTORE2.read(chunk1),
            SSTORE2.read(chunk2),
            SSTORE2.read(chunk3),
            SSTORE2.read(chunk4),
            SSTORE2.read(chunk5)
        );
        for (uint256 i; i < shredCounter; i++) {
            uint256 j = i; 
            for (; j < chunkLength * 5; j += 256) {
                original[j] = modeHistory[i] ? light : darkness;
            }
        }
        return string(original);
    }

    function switchModes() external {
        _mode = !_mode;
    }

    function mode() external view returns (string memory) {
        return _mode ? "light" : "dark";
    }

    function shred() external {
        if (shredCounter < 256) {
            shredCounter++;
            modeHistory.push(_mode);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"mode","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"read","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"shred","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shredCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"switchModes","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

12430:1572:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13740:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13667:65;;13719:5;;;-1:-1:-1;;13710:14:0;;13719:5;;;;13718:6;13710:14;;;13667:65;;;13070:27;;;;;;;;;816:25:1;;;804:2;789:18;13070:27:0;670:177:1;13852:147:0;;;:::i;13106:553::-;;;:::i;13740:104::-;13812:5;;13779:13;;13812:5;;:24;;-1:-1:-1;13812:24:0;;;;;;;;;;;;-1:-1:-1;;;13812:24:0;;;;;13740:104::o;13812:24::-;-1:-1:-1;13812:24:0;;;;;;;;;;;;-1:-1:-1;;;13812:24:0;;;;;13740:104::o;13852:147::-;13908:3;13893:12;;:18;13889:103;;;13928:12;:14;;;:12;:14;;;:::i;:::-;;;;-1:-1:-1;;13974:5:0;;;13957:11;:23;;;;;;;;;;;;;;;;13974:5;;;;13957:23;;;;;;13974:5;13957:23;;;;;;;;;;;;;;;;;;13889:103;13852:147::o;13106:553::-;13145:13;13171:21;13222:20;12489:42;13222:12;:20::i;:::-;13257;12572:42;13257:12;:20::i;:::-;13292;12655:42;13292:12;:20::i;:::-;13327;12738:42;13327:12;:20::i;:::-;13362;12821:42;13362:12;:20::i;:::-;13195:198;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;13171:222;;13409:9;13404:214;13424:12;;13420:1;:16;13404:214;;;13470:1;13487:120;13498:15;12909:5;13512:1;13498:15;:::i;:::-;13494:1;:19;13487:120;;;13558:11;13570:1;13558:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:33;;-1:-1:-1;;;13558:33:0;;;-1:-1:-1;;;13558:33:0;13544:8;13553:1;13544:11;;;;;;;;:::i;:::-;;;;:47;-1:-1:-1;;;;;13544:47:0;;;;;;;;-1:-1:-1;13515:8:0;13520:3;13515:8;;:::i;:::-;;;13487:120;;;-1:-1:-1;13438:3:0;;;;:::i;:::-;;;;13404:214;;;-1:-1:-1;13642:8:0;13106:553;-1:-1:-1;13106:553:0:o;7521:1166::-;7575:17;7708:7;7696:20;7740:15;7730:240;;7860:10;7854:4;7847:24;7950:4;7944;7937:18;7730:240;8082:11;8065:15;8061:33;8049:45;;8418:4;8412:11;8404:19;;8481:6;8474:4;8468;8464:15;8460:28;8454:4;8450:39;8444:4;8437:53;8517:4;8511;8504:18;8571:1;8564:4;8557;8551;8547:15;8543:26;8536:37;8664:4;8651:11;8644:4;8638;8634:15;8625:7;8613:56;;7521:1166;;;:::o;14:250:1:-;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:1;238:16;;231:27;14:250::o;269:396::-;418:2;407:9;400:21;381:4;450:6;444:13;493:6;488:2;477:9;473:18;466:34;509:79;581:6;576:2;565:9;561:18;556:2;548:6;544:15;509:79;:::i;:::-;649:2;628:15;-1:-1:-1;;624:29:1;609:45;;;;656:2;605:54;;269:396;-1:-1:-1;;269:396:1:o;852:127::-;913:10;908:3;904:20;901:1;894:31;944:4;941:1;934:15;968:4;965:1;958:15;984:135;1023:3;1044:17;;;1041:43;;1064:18;;:::i;:::-;-1:-1:-1;1111:1:1;1100:13;;984:135::o;1124:1107::-;1437:3;1475:6;1469:13;1491:66;1550:6;1545:3;1538:4;1530:6;1526:17;1491:66;:::i;:::-;1620:13;;1579:16;;;;1642:70;1620:13;1579:16;1689:4;1677:17;;1642:70;:::i;:::-;1779:13;;1734:20;;;1801:70;1779:13;1734:20;1848:4;1836:17;;1801:70;:::i;:::-;1938:13;;1893:20;;;1960:70;1938:13;1893:20;2007:4;1995:17;;1960:70;:::i;:::-;2097:13;;2052:20;;;2119:70;2097:13;2052:20;2166:4;2154:17;;2119:70;:::i;:::-;2205:20;;1124:1107;-1:-1:-1;;;;;;;1124:1107:1:o;2236:168::-;2309:9;;;2340;;2357:15;;;2351:22;;2337:37;2327:71;;2378:18;;:::i;:::-;2236:168;;;;:::o;2409:127::-;2470:10;2465:3;2461:20;2458:1;2451:31;2501:4;2498:1;2491:15;2525:4;2522:1;2515:15;2541:125;2606:9;;;2627:10;;;2624:36;;;2640:18;;:::i

ipfs://c7abf864dfd3cbd3af4f8d1ee95778891a26a558ee9324e2e623630e2f8c9725