@artblocks/contracts 1.0.1 → 1.0.3

package/contracts/libs/0.8.x/SSTORE2.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity >=0.8.0;
+
+/// @notice Read and write to persistent storage at a fraction of the cost.
+/// @author 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 {
+    uint256 internal constant DATA_OFFSET = 1; // We skip the first byte as it's a STOP opcode to ensure the contract can't be called.
+
+    /*//////////////////////////////////////////////////////////////
+                               WRITE LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function write(bytes memory data) internal returns (address pointer) {
+        // Prefix the bytecode with a STOP opcode to ensure it cannot be called.
+        bytes memory runtimeCode = abi.encodePacked(hex"00", data);
+
+        bytes memory creationCode = abi.encodePacked(
+            //---------------------------------------------------------------------------------------------------------------//
+            // Opcode  | Opcode + Arguments  | Description  | Stack View                                                     //
+            //---------------------------------------------------------------------------------------------------------------//
+            // 0x60    |  0x600B             | PUSH1 11     | codeOffset                                                     //
+            // 0x59    |  0x59               | MSIZE        | 0 codeOffset                                                   //
+            // 0x81    |  0x81               | DUP2         | codeOffset 0 codeOffset                                        //
+            // 0x38    |  0x38               | CODESIZE     | codeSize codeOffset 0 codeOffset                               //
+            // 0x03    |  0x03               | SUB          | (codeSize - codeOffset) 0 codeOffset                           //
+            // 0x80    |  0x80               | DUP          | (codeSize - codeOffset) (codeSize - codeOffset) 0 codeOffset   //
+            // 0x92    |  0x92               | SWAP3        | codeOffset (codeSize - codeOffset) 0 (codeSize - codeOffset)   //
+            // 0x59    |  0x59               | MSIZE        | 0 codeOffset (codeSize - codeOffset) 0 (codeSize - codeOffset) //
+            // 0x39    |  0x39               | CODECOPY     | 0 (codeSize - codeOffset)                                      //
+            // 0xf3    |  0xf3               | RETURN       |                                                                //
+            //---------------------------------------------------------------------------------------------------------------//
+            hex"60_0B_59_81_38_03_80_92_59_39_F3", // Returns all code in the contract except for the first 11 (0B in hex) bytes.
+            runtimeCode // The bytecode we want the contract to have after deployment. Capped at 1 byte less than the code size limit.
+        );
+
+        /// @solidity memory-safe-assembly
+        assembly {
+            // Deploy a new contract with the generated creation code.
+            // We start 32 bytes into the code to avoid copying the byte length.
+            pointer := create(0, add(creationCode, 32), mload(creationCode))
+        }
+
+        require(pointer != address(0), "DEPLOYMENT_FAILED");
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                               READ LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function read(address pointer) internal view returns (bytes memory) {
+        return
+            readBytecode(
+                pointer,
+                DATA_OFFSET,
+                pointer.code.length - DATA_OFFSET
+            );
+    }
+
+    function read(
+        address pointer,
+        uint256 start
+    ) internal view returns (bytes memory) {
+        start += DATA_OFFSET;
+
+        return readBytecode(pointer, start, pointer.code.length - start);
+    }
+
+    function read(
+        address pointer,
+        uint256 start,
+        uint256 end
+    ) internal view returns (bytes memory) {
+        start += DATA_OFFSET;
+        end += DATA_OFFSET;
+
+        require(pointer.code.length >= end, "OUT_OF_BOUNDS");
+
+        return readBytecode(pointer, start, end - start);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                          INTERNAL HELPER LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function readBytecode(
+        address pointer,
+        uint256 start,
+        uint256 size
+    ) private view returns (bytes memory data) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            // Get a pointer to some free memory.
+            data := mload(0x40)
+
+            // Update the free memory pointer to prevent overriding our data.
+            // We use and(x, not(31)) as a cheaper equivalent to sub(x, mod(x, 32)).
+            // Adding 31 to size and running the result through the logic above ensures
+            // the memory pointer remains word-aligned, following the Solidity convention.
+            mstore(0x40, add(data, and(add(add(size, 32), 31), not(31))))
+
+            // Store the size of the data in the first 32 byte chunk of free memory.
+            mstore(data, size)
+
+            // Copy the code into memory right after the 32 bytes we used to store the size.
+            extcodecopy(pointer, add(data, 32), start, size)
+        }
+    }
+}

package/contracts/libs/integration-refs/delegation-registry/DelegationRegistry.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: CC0-1.0
-pragma solidity ^0.8.17;
+pragma solidity ^0.8.19;
 
 // This is a mock contract to be used in tests.
 // The source code is copied from ETH mainnet, deployed at:0x00000000000076a84fef008cdabe6409d2fe638b