Predeploys should be proxies

Author: RogerPodacter

contracts/script/L2Genesis.s.sol

@@ -183,24 +183,42 @@ contract L2Genesis is Script {
 
     /// @notice Set up Ethscriptions system contracts
     function setEthscriptionsPredeploys() internal {
-        // Create genesis Ethscriptions first (this handles the Ethscriptions contract setup)
+        // Ensure proxies exist across the full 0x330… namespace, mirroring OP's approach
+        bytes memory proxyCode = vm.getDeployedCode("Proxy.sol:Proxy");
+        uint160 prefix = uint160(0x330) << 148;
 
-        // Deploy other Ethscriptions-related contracts
-        _setEthscriptionsCode(Predeploys.TOKEN_MANAGER, "TokenManager");
-        _setEthscriptionsCode(Predeploys.COLLECTIONS_MANAGER, "CollectionsManager");
-        _setEthscriptionsCode(Predeploys.ETHSCRIPTIONS_PROVER, "EthscriptionsProver");
-        _setEthscriptionsCode(Predeploys.ERC20_TEMPLATE, "EthscriptionsERC20");
-        _setEthscriptionsCode(Predeploys.ERC721_TEMPLATE, "EthscriptionERC721");
+        for (uint256 i = 0; i < PREDEPLOY_COUNT; i++) {
+            address addr = address(prefix | uint160(i));
 
+            // Deploy proxy shell and prime nonce for deterministic CREATEs
+            vm.etch(addr, proxyCode);
+            vm.setNonce(addr, 1);
+            setProxyAdminSlot(addr, Predeploys.PROXY_ADMIN);
+
+            // Wire up implementations for the Ethscriptions predeploys that use proxies
+            bool isProxiedContract = addr == Predeploys.ETHSCRIPTIONS ||
+                addr == Predeploys.TOKEN_MANAGER ||
+                addr == Predeploys.ETHSCRIPTIONS_PROVER ||
+                addr == Predeploys.COLLECTIONS_MANAGER;
+            if (isProxiedContract) {
+                address impl = Predeploys.predeployToCodeNamespace(addr);
+                setImplementation(addr, impl);
+            }
+        }
+
+        // Set implementation code for non-ETHSCRIPTIONS contracts now
+        _setImplementationCodeNamed(Predeploys.TOKEN_MANAGER, "TokenManager");
+        _setImplementationCodeNamed(Predeploys.COLLECTIONS_MANAGER, "CollectionsManager");
+        _setImplementationCodeNamed(Predeploys.ETHSCRIPTIONS_PROVER, "EthscriptionsProver");
+        // Templates live directly at their implementation addresses (no proxy wrapping)
+        _setCodeAt(Predeploys.ERC20_TEMPLATE_IMPLEMENTATION, "EthscriptionsERC20");
+        _setCodeAt(Predeploys.ERC721_TEMPLATE_IMPLEMENTATION, "EthscriptionERC721");
+
+        // Create genesis Ethscriptions (writes via proxy to proxy storage)
         createGenesisEthscriptions();
 
-        // Register protocol handlers
+        // Register protocol handlers via the Ethscriptions proxy
         registerProtocolHandlers();
-
-        // Disable initializers on all Ethscriptions contracts
-        _disableInitializers(Predeploys.ETHSCRIPTIONS);
-        _disableInitializers(Predeploys.ERC20_TEMPLATE);
-        _disableInitializers(Predeploys.ERC721_TEMPLATE);
     }
 
     /// @notice Register protocol handlers with the Ethscriptions contract
@@ -265,13 +283,15 @@ contract L2Genesis is Script {
         uint256 totalCount = abi.decode(vm.parseJson(json, ".metadata.totalCount"), (uint256));
         console.log("Found", totalCount, "genesis Ethscriptions");
 
-        // First, etch the GenesisEthscriptions contract temporarily
-        address ethscriptionsAddr = Predeploys.ETHSCRIPTIONS;
-        vm.etch(ethscriptionsAddr, type(GenesisEthscriptions).runtimeCode);
+        // Use the Ethscriptions proxy address and its implementation code-namespace address
+        address ethscriptionsProxy = Predeploys.ETHSCRIPTIONS;
+        address implAddr = Predeploys.predeployToCodeNamespace(ethscriptionsProxy);
 
-        vm.setNonce(ethscriptionsAddr, 1);
+        // Temporarily etch GenesisEthscriptions at the implementation address
+        vm.etch(implAddr, type(GenesisEthscriptions).runtimeCode);
 
-        GenesisEthscriptions genesisContract = GenesisEthscriptions(ethscriptionsAddr);
+        // Call through the proxy using the GenesisEthscriptions interface
+        GenesisEthscriptions genesisContract = GenesisEthscriptions(ethscriptionsProxy);
 
         // Process each ethscription (this will increment the nonce as SSTORE2 contracts are deployed)
         for (uint256 i = 0; i < totalCount; i++) {
@@ -280,9 +300,9 @@ contract L2Genesis is Script {
 
         console.log("Created", totalCount, "genesis Ethscriptions");
 
-        // Now etch the real Ethscriptions contract over the GenesisEthscriptions
-        // IMPORTANT: Do NOT reset the nonce here - it needs to continue from where it left off
-        _setEthscriptionsCode(ethscriptionsAddr, "Ethscriptions");
+        // Overwrite the implementation bytecode with the real Ethscriptions
+        // Do not reset nonce on the proxy; we only swap the implementation code
+        _setImplementationCodeNamed(Predeploys.ETHSCRIPTIONS, "Ethscriptions");
     }
 
     /// @notice Helper to create a single genesis ethscription
@@ -343,11 +363,22 @@ contract L2Genesis is Script {
         vm.store(_addr, Constants.INITIALIZABLE_STORAGE, bytes32(uint256(0x000000000000000000000000000000000000000000000000ffffffffffffffff)));
     }
 
-    /// @notice Set bytecode for Ethscriptions contracts
-    function _setEthscriptionsCode(address _addr, string memory _name) internal {
+    /// @notice Set implementation bytecode for a given predeploy using an explicit contract name
+    function _setImplementationCodeNamed(address _predeploy, string memory _name) internal returns (address impl) {
+        impl = Predeploys.predeployToCodeNamespace(_predeploy);
+        bytes memory code = vm.getDeployedCode(string.concat(_name, ".sol:", _name));
+        console.log("Setting implementation code for", _predeploy, "to", impl);
+        
+        _disableInitializers(impl);
+        
+        vm.etch(impl, code);
+    }
+
+    /// @notice Etch contract bytecode directly at a target address (used for non-proxy templates)
+    function _setCodeAt(address _addr, string memory _name) internal {
         bytes memory code = vm.getDeployedCode(string.concat(_name, ".sol:", _name));
+        _disableInitializers(_addr);
         vm.etch(_addr, code);
-        // Don't reset nonce here - let the caller manage it
     }
 
     /// @notice Set the admin of a proxy contract

contracts/src/CollectionsManager.sol

@@ -96,7 +96,7 @@ contract CollectionsManager is IProtocolHandler {
         // Note: Similar to ItemData but without ethscriptionId (can't change)
     }
 
-    address public constant erc721Template = Predeploys.ERC721_TEMPLATE;
+    address public constant erc721Template = Predeploys.ERC721_TEMPLATE_IMPLEMENTATION;
     address public constant ethscriptions = Predeploys.ETHSCRIPTIONS;
 
     // Track deployed collections by ID

contracts/src/TokenManager.sol

@@ -40,7 +40,7 @@ contract TokenManager is IProtocolHandler {
         uint256 amount;
     }
 
-    address public constant erc20Template = Predeploys.ERC20_TEMPLATE;
+    address public constant erc20Template = Predeploys.ERC20_TEMPLATE_IMPLEMENTATION;
     address public constant ethscriptions = Predeploys.ETHSCRIPTIONS;
 
     // Track deployed tokens by protocol+tick for find-or-create

contracts/src/libraries/Predeploys.sol

@@ -19,32 +19,49 @@ library Predeploys {
     address constant PROXY_ADMIN = 0x4200000000000000000000000000000000000018;
 
     // ============ Ethscriptions System Predeploys ============
-    // Using 0xee namespace for Ethscriptions contracts
+    // Using 0x3300… namespace for Ethscriptions contracts
 
     /// @notice Ethscriptions NFT contract
-    address constant ETHSCRIPTIONS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    /// @dev Moved to the 0x3300… namespace to align with other Ethscriptions predeploys
+    address constant ETHSCRIPTIONS = 0x3300000000000000000000000000000000000001;
 
     /// @notice TokenManager for ERC20 token creation
     address constant TOKEN_MANAGER = 0x3300000000000000000000000000000000000002;
 
     /// @notice EthscriptionsProver for L1 provability
     address constant ETHSCRIPTIONS_PROVER = 0x3300000000000000000000000000000000000003;
-    
-    /// @notice EthscriptionsERC20 template for cloning
-    address constant ERC20_TEMPLATE = 0x3300000000000000000000000000000000000004;
 
-    /// @notice EthscriptionERC721 template for cloning (collections)
-    address constant ERC721_TEMPLATE = 0x3300000000000000000000000000000000000005;
+    /// @notice Proxy address reserved for the ERC20 template (blank proxy)
+    address constant ERC20_TEMPLATE_PROXY = 0x3300000000000000000000000000000000000004;
+
+    /// @notice Implementation address for the ERC20 template (actual logic contract)
+    address constant ERC20_TEMPLATE_IMPLEMENTATION = 0xc0D3c0D3c0D3c0d3c0d3C0d3C0d3c0D3C0D30004;
+
+    /// @notice Proxy address reserved for the ERC721 template (blank proxy)
+    address constant ERC721_TEMPLATE_PROXY = 0x3300000000000000000000000000000000000005;
+
+    /// @notice Implementation address for the ERC721 template (actual logic contract)
+    address constant ERC721_TEMPLATE_IMPLEMENTATION = 0xc0d3C0d3c0D3c0d3C0D3C0D3c0D3C0D3c0d30005;
 
     /// @notice CollectionsManager for collections protocol
     address constant COLLECTIONS_MANAGER = 0x3300000000000000000000000000000000000006;
 
     // ============ Helper Functions ============
 
-    /// @notice Returns true if the address is a predeploy
-    function isPredeployNamespace(address _addr) internal pure returns (bool) {
+    /// @notice Returns true if the address is an OP Stack predeploy (0x4200… namespace)
+    function isOPPredeployNamespace(address _addr) internal pure returns (bool) {
         return uint160(_addr) >> 11 == uint160(0x4200000000000000000000000000000000000000) >> 11;
     }
+
+    /// @notice Returns true if the address is an Ethscriptions predeploy (0x3300… namespace)
+    function isEthscriptionsPredeployNamespace(address _addr) internal pure returns (bool) {
+        return uint160(_addr) >> 11 == uint160(0x3300000000000000000000000000000000000000) >> 11;
+    }
+
+    /// @notice Returns true if the address is a recognized predeploy (OP or Ethscriptions)
+    function isPredeployNamespace(address _addr) internal pure returns (bool) {
+        return isOPPredeployNamespace(_addr) || isEthscriptionsPredeployNamespace(_addr);
+    }
 
     /// @notice Converts a predeploy address to its code namespace equivalent
     function predeployToCodeNamespace(address _addr) internal pure returns (address) {
@@ -56,4 +73,4 @@ library Predeploys {
             uint160(uint256(uint160(_addr)) & 0xffff | uint256(uint160(0xc0D3C0d3C0d3C0D3c0d3C0d3c0D3C0d3c0d30000)))
         );
     }
-}
+}

lib/event_decoder.rb

@@ -16,7 +16,7 @@ class EventDecoder
     'Transfer(address,address,uint256)'
   ).unpack1('H*')
 
-  ETHSCRIPTIONS_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'
+  ETHSCRIPTIONS_ADDRESS = SysConfig::ETHSCRIPTIONS_ADDRESS.to_hex
 
   class << self
     def decode_receipt_logs(receipt)

lib/storage_reader.rb

@@ -1,5 +1,5 @@
 class StorageReader
-  ETHSCRIPTIONS_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'
+  ETHSCRIPTIONS_ADDRESS = SysConfig::ETHSCRIPTIONS_ADDRESS.to_hex
 
   # Define the nested ContentInfo struct
   CONTENT_INFO_STRUCT = {

lib/sys_config.rb

@@ -8,7 +8,7 @@ module SysConfig
   # System addresses (matching Solidity contracts)
   SYSTEM_ADDRESS = Address20.from_hex("0xdeaddeaddeaddeaddeaddeaddeaddeaddead0001")
   L1_INFO_ADDRESS = Address20.from_hex("0x4200000000000000000000000000000000000015")
-  ETHSCRIPTIONS_ADDRESS = Address20.from_hex("0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE")
+  ETHSCRIPTIONS_ADDRESS = Address20.from_hex("0x3300000000000000000000000000000000000001")
   TOKEN_MANAGER_ADDRESS = Address20.from_hex("0x3300000000000000000000000000000000000002")
 
   # Deposit transaction domains