Merge pull request #127 from ethscriptions-protocol/rename

Big rename

Author: RogerPodacter

app/models/token_params_extractor.rb …fixed_fungible_token_params_extractor.rbapp/models/token_params_extractor.rb renamed to app/models/fixed_fungible_token_params_extractor.rb app/models/token_params_extractor.rb renamed to app/models/fixed_fungible_token_params_extractor.rb

@@ -1,16 +1,17 @@
-# Extracts token parameters from content URIs using strict regex validation
+# Extracts fixed-fungible token parameters from content URIs using strict regex validation
 # Protocol uniqueness is based on exact text matching, so we validate the exact format
-class TokenParamsExtractor
+class FixedFungibleTokenParamsExtractor
   # Constants
   DEFAULT_PARAMS = [''.b, ''.b, ''.b, 0, 0, 0].freeze
   UINT256_MAX = 2**256 - 1
-
+  
   # Exact regex patterns for valid formats
-  # Protocol must be "erc-20" (not captured since it's fixed)
+  # Protocol must be "erc-20" or "fixed-fungible" (case-sensitive)
   # Tick must be lowercase letters/numbers, max 28 chars
   # Numbers must be positive decimals without leading zeros
-  DEPLOY_REGEX = /\Adata:,\{"p":"erc-20","op":"deploy","tick":"([a-z0-9]{1,28})","max":"(0|[1-9][0-9]*)","lim":"(0|[1-9][0-9]*)"\}\z/
-  MINT_REGEX = /\Adata:,\{"p":"erc-20","op":"mint","tick":"([a-z0-9]{1,28})","id":"(0|[1-9][0-9]*)","amt":"(0|[1-9][0-9]*)"\}\z/
+  PROTOCOL_PATTERN = '(?:erc-20|fixed-fungible)'
+  DEPLOY_REGEX = /\Adata:,\{"p":"#{PROTOCOL_PATTERN}","op":"deploy","tick":"([a-z0-9]{1,28})","max":"(0|[1-9][0-9]*)","lim":"(0|[1-9][0-9]*)"\}\z/
+  MINT_REGEX = /\Adata:,\{"p":"#{PROTOCOL_PATTERN}","op":"mint","tick":"([a-z0-9]{1,28})","id":"(0|[1-9][0-9]*)","amt":"(0|[1-9][0-9]*)"\}\z/
 
   def self.extract(content_uri)
     return DEFAULT_PARAMS unless content_uri.is_a?(String)
@@ -24,7 +25,7 @@ def self.extract(content_uri)
       # Validate uint256 bounds
       return DEFAULT_PARAMS if max > UINT256_MAX || lim > UINT256_MAX
 
-      return ['deploy'.b, 'erc-20'.b, tick.b, max, lim, 0]
+      return ['deploy'.b, 'fixed-fungible'.b, tick.b, max, lim, 0]
     end
 
     # Try mint format
@@ -36,7 +37,7 @@ def self.extract(content_uri)
       # Validate uint256 bounds
       return DEFAULT_PARAMS if id > UINT256_MAX || amt > UINT256_MAX
 
-      return ['mint'.b, 'erc-20'.b, tick.b, id, 0, amt]
+      return ['mint'.b, 'fixed-fungible'.b, tick.b, id, 0, amt]
     end
 
     # No match - return default

app/models/generic_protocol_extractor.rb

@@ -572,9 +572,9 @@ def handle_bytes_hint(type_hint, value)
     [type_hint, [hex_part.downcase].pack('H*')]
   end
 
-  # Helper method for legacy token protocol (maintains compatibility)
+  # Helper method for fixed-fungible protocol parsing (shared with protocol extractor)
   def self.extract_token_params(content_uri)
     # Use the strict regex-based extractor for token protocol
-    TokenParamsExtractor.extract(content_uri)
+    FixedFungibleTokenParamsExtractor.extract(content_uri)
   end
 end

app/models/protocol_extractor.rb

@@ -1,7 +1,7 @@
 # Unified protocol extractor that delegates to appropriate extractors
 class ProtocolExtractor
   # Default return values to check if extraction succeeded
-  TOKEN_DEFAULT_PARAMS = TokenParamsExtractor::DEFAULT_PARAMS
+  TOKEN_DEFAULT_PARAMS = FixedFungibleTokenParamsExtractor::DEFAULT_PARAMS
   COLLECTIONS_DEFAULT_PARAMS = CollectionsParamsExtractor::DEFAULT_PARAMS
   GENERIC_DEFAULT_PARAMS = GenericProtocolExtractor::DEFAULT_PARAMS
 
@@ -45,15 +45,15 @@ def self.extract(content_uri)
   private
 
   def self.try_token_extractor(content_uri)
-    # TokenParamsExtractor uses strict regex and returns DEFAULT_PARAMS if no match
+    # FixedFungibleTokenParamsExtractor uses strict regex and returns DEFAULT_PARAMS if no match
     # This enforces non-ESIP6 and exact JSON formatting implicitly.
-    params = TokenParamsExtractor.extract(content_uri)
+    params = FixedFungibleTokenParamsExtractor.extract(content_uri)
 
     # Check if extraction succeeded (returns non-default params)
     if params != TOKEN_DEFAULT_PARAMS
       {
-        type: :token,
-        protocol: 'erc-20',
+        type: :fixed_fungible,
+        protocol: 'fixed-fungible',
         operation: params[0], # 'deploy' or 'mint'
         params: params,
         encoded_params: encode_token_params(params)
@@ -135,8 +135,8 @@ def self.for_calldata(content_uri)
     if result.nil?
       # No protocol detected - return empty protocol params
       [''.b, ''.b, ''.b]
-    elsif result[:type] == :token
-      # Token protocol - return in new format
+    elsif result[:type] == :fixed_fungible
+      # Fixed-fungible protocol - return in ABI-ready format
       protocol = result[:protocol].b
       operation = result[:operation]
       # For tokens, encode the params properly
@@ -158,7 +158,7 @@ def self.encode_token_data(params)
 
     # Encode based on operation type (operation is passed separately now)
     # Use tuple encoding for struct compatibility with contracts
-    # IMPORTANT: Field order must match TokenManager's struct definitions!
+    # IMPORTANT: Field order must match FixedFungibleProtocolHandler's struct definitions!
     if op == 'deploy'.b
       # DeployOperation struct: tick, maxSupply, mintAmount
       # Our params: tick, max (val1), lim (val2)

contracts/script/L2Genesis.s.sol

@@ -198,22 +198,22 @@ contract L2Genesis is Script {
 
             // Wire up implementations for the Ethscriptions predeploys that use proxies
             bool isProxiedContract = addr == Predeploys.ETHSCRIPTIONS ||
-                addr == Predeploys.TOKEN_MANAGER ||
+                addr == Predeploys.FIXED_FUNGIBLE_HANDLER ||
                 addr == Predeploys.ETHSCRIPTIONS_PROVER ||
-                addr == Predeploys.COLLECTIONS_MANAGER;
+                addr == Predeploys.COLLECTIONS_PROTOCOL_HANDLER;
             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.FIXED_FUNGIBLE_HANDLER, "FixedFungibleProtocolHandler");
+        _setImplementationCodeNamed(Predeploys.COLLECTIONS_PROTOCOL_HANDLER, "CollectionsProtocolHandler");
         _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");
+        _setCodeAt(Predeploys.FIXED_FUNGIBLE_TEMPLATE_IMPLEMENTATION, "FixedFungibleERC20");
+        _setCodeAt(Predeploys.COLLECTIONS_TEMPLATE_IMPLEMENTATION, "CollectionsERC721");
 
         // Create genesis Ethscriptions (writes via proxy to proxy storage)
         createGenesisEthscriptions();
@@ -226,18 +226,18 @@ contract L2Genesis is Script {
     function registerProtocolHandlers() internal {
         Ethscriptions ethscriptions = Ethscriptions(Predeploys.ETHSCRIPTIONS);
 
-        ethscriptions.registerProtocol("erc-20", Predeploys.TOKEN_MANAGER);
-        console.log("Registered erc-20 protocol handler:", Predeploys.TOKEN_MANAGER);
+        ethscriptions.registerProtocol("fixed-fungible", Predeploys.FIXED_FUNGIBLE_HANDLER);
+        console.log("Registered fixed-fungible protocol handler:", Predeploys.FIXED_FUNGIBLE_HANDLER);
 
         // Check environment variable for collections
         // Default to true so forge tests work (they don't go through genesis_generator.rb)
         // Production explicitly sets ENABLE_COLLECTIONS=false
         bool enableCollections = vm.envOr("ENABLE_COLLECTIONS", true);
 
         if (enableCollections) {
-            // Register the CollectionsManager as the handler for collections protocol
-            ethscriptions.registerProtocol("collections", Predeploys.COLLECTIONS_MANAGER);
-            console.log("Registered collections protocol handler:", Predeploys.COLLECTIONS_MANAGER);
+            // Register the collections protocol handler for collections operations
+            ethscriptions.registerProtocol("collections", Predeploys.COLLECTIONS_PROTOCOL_HANDLER);
+            console.log("Registered collections protocol handler:", Predeploys.COLLECTIONS_PROTOCOL_HANDLER);
         } else {
             console.log("Collections protocol not registered (ENABLE_COLLECTIONS=false)");
         }

contracts/src/EthscriptionERC721.sol contracts/src/CollectionsERC721.solcontracts/src/EthscriptionERC721.sol renamed to contracts/src/CollectionsERC721.sol

@@ -8,12 +8,12 @@ import "./ERC721EthscriptionsUpgradeable.sol";
 import "./Ethscriptions.sol";
 import {LibString} from "solady/utils/LibString.sol";
 import {Base64} from "solady/utils/Base64.sol";
-import "./CollectionsManager.sol";
+import "./CollectionsProtocolHandler.sol";
 
-/// @title EthscriptionERC721
+/// @title CollectionsERC721
 /// @notice ERC-721 contract for an Ethscription collection
 /// @dev Maintains internal state but overrides ownerOf to delegate to Ethscriptions contract
-contract EthscriptionERC721 is ERC721EthscriptionsUpgradeable {
+contract CollectionsERC721 is ERC721EthscriptionsUpgradeable {
     using LibString for *;
 
     /// @notice The main Ethscriptions contract
@@ -125,8 +125,8 @@ contract EthscriptionERC721 is ERC721EthscriptionsUpgradeable {
         }
 
         // Get ethscription ID from manager
-        CollectionsManager manager = CollectionsManager(factory);
-        CollectionsManager.CollectionItem memory item = manager.getCollectionItem(collectionId, tokenId);
+        CollectionsProtocolHandler manager = CollectionsProtocolHandler(factory);
+        CollectionsProtocolHandler.CollectionItem memory item = manager.getCollectionItem(collectionId, tokenId);
 
         if (item.ethscriptionId == bytes32(0)) {
             revert("Token not in collection");
@@ -142,9 +142,9 @@ contract EthscriptionERC721 is ERC721EthscriptionsUpgradeable {
             revert("Token does not exist");
         }
 
-        // Get collection metadata and item data from CollectionsManager
-        CollectionsManager manager = CollectionsManager(factory);
-        CollectionsManager.CollectionItem memory item = manager.getCollectionItem(collectionId, tokenId);
+        // Get collection metadata and item data from CollectionsProtocolHandler
+        CollectionsProtocolHandler manager = CollectionsProtocolHandler(factory);
+        CollectionsProtocolHandler.CollectionItem memory item = manager.getCollectionItem(collectionId, tokenId);
 
         if (item.ethscriptionId == bytes32(0)) {
             revert("Token not in collection");

contracts/src/CollectionsManager.sol …racts/src/CollectionsProtocolHandler.solcontracts/src/CollectionsManager.sol renamed to contracts/src/CollectionsProtocolHandler.sol contracts/src/CollectionsManager.sol renamed to contracts/src/CollectionsProtocolHandler.sol

@@ -3,12 +3,12 @@ pragma solidity 0.8.24;
 
 import "@openzeppelin/contracts/proxy/Clones.sol";
 import {LibString} from "solady/utils/LibString.sol";
-import "./EthscriptionERC721.sol";
+import "./CollectionsERC721.sol";
 import "./Ethscriptions.sol";
 import "./libraries/Predeploys.sol";
 import "./interfaces/IProtocolHandler.sol";
 
-contract CollectionsManager is IProtocolHandler {
+contract CollectionsProtocolHandler is IProtocolHandler {
     using Clones for address;
     using LibString for string;
 
@@ -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_IMPLEMENTATION;
+    address public constant collectionsTemplate = Predeploys.COLLECTIONS_TEMPLATE_IMPLEMENTATION;
     address public constant ethscriptions = Predeploys.ETHSCRIPTIONS;
 
     // Track deployed collections by ID
@@ -157,10 +157,10 @@ contract CollectionsManager is IProtocolHandler {
         uint256 totalSupply = metadata.totalSupply;
 
         // Deploy ERC721 clone with CREATE2 using collectionId as salt for deterministic address
-        address collectionContract = erc721Template.cloneDeterministic(collectionId);
+        address collectionContract = collectionsTemplate.cloneDeterministic(collectionId);
 
         // Initialize the clone with basic info
-        EthscriptionERC721(collectionContract).initialize(
+        CollectionsERC721(collectionContract).initialize(
             metadata.name,
             metadata.symbol,
             collectionId
@@ -211,7 +211,7 @@ contract CollectionsManager is IProtocolHandler {
         }
 
         // Add each item with full metadata
-        EthscriptionERC721 collectionContract = EthscriptionERC721(collection.collectionContract);
+        CollectionsERC721 collectionContract = CollectionsERC721(collection.collectionContract);
 
         for (uint256 i = 0; i < addOp.items.length; i++) {
             ItemData memory itemData = addOp.items[i];
@@ -271,7 +271,7 @@ contract CollectionsManager is IProtocolHandler {
         require(currentOwner == sender, "Only collection owner can remove items");
 
         // Remove each ethscription from the collection
-        EthscriptionERC721 collectionContract = EthscriptionERC721(collection.collectionContract);
+        CollectionsERC721 collectionContract = CollectionsERC721(collection.collectionContract);
         for (uint256 i = 0; i < removeOp.ethscriptionIds.length; i++) {
             bytes32 ethscriptionId = removeOp.ethscriptionIds[i];
 
@@ -374,7 +374,7 @@ contract CollectionsManager is IProtocolHandler {
         require(currentOwner == sender, "Only collection owner can lock");
 
         collection.locked = true;
-        EthscriptionERC721(collection.collectionContract).lockCollection();
+        CollectionsERC721(collection.collectionContract).lockCollection();
         emit CollectionLocked(collectionId);
         emit ProtocolHandlerSuccess(txHash, protocolName());
     }
@@ -389,7 +389,7 @@ contract CollectionsManager is IProtocolHandler {
         CollectionState memory collection = collectionState[collectionId];
         require(collection.collectionContract != address(0), "Collection does not exist");
 
-        EthscriptionERC721 collectionContract = EthscriptionERC721(collection.collectionContract);
+        CollectionsERC721 collectionContract = CollectionsERC721(collection.collectionContract);
 
         // Sync ownership for specified ethscriptions in this collection
         for (uint256 i = 0; i < ethscriptionIds.length; i++) {
@@ -419,7 +419,7 @@ contract CollectionsManager is IProtocolHandler {
         //     CollectionState memory collection = collectionState[item.collectionId];
         //     if (collection.collectionContract != address(0)) {
         //         // Sync the ownership in the ERC721 contract
-        //         EthscriptionERC721(collection.collectionContract).syncOwnership(item.tokenId);
+        //         CollectionsERC721(collection.collectionContract).syncOwnership(item.tokenId);
         //     }
         // }
     }
@@ -459,7 +459,7 @@ contract CollectionsManager is IProtocolHandler {
         }
 
         // Predict using CREATE2
-        return Clones.predictDeterministicAddress(erc721Template, collectionId, address(this));
+        return Clones.predictDeterministicAddress(collectionsTemplate, collectionId, address(this));
     }
 
     function getAllCollections() external view returns (bytes32[] memory) {

contracts/src/EthscriptionsERC20.sol contracts/src/FixedFungibleERC20.solcontracts/src/EthscriptionsERC20.sol renamed to contracts/src/FixedFungibleERC20.sol

@@ -4,17 +4,17 @@ pragma solidity 0.8.24;
 import "./ERC20NullOwnerCappedUpgradeable.sol";
 import "./libraries/Predeploys.sol";
 
-/// @title EthscriptionsERC20
-/// @notice ERC20 with cap that supports null address ownership
-/// @dev Only TokenManager can mint/transfer. User-initiated transfers are disabled.
-contract EthscriptionsERC20 is ERC20NullOwnerCappedUpgradeable {
+/// @title FixedFungibleERC20
+/// @notice ERC-20 clone whose balances are controlled by the FixedFungible protocol handler
+/// @dev User-initiated transfers/approvals are disabled; only the handler can mutate balances.
+contract FixedFungibleERC20 is ERC20NullOwnerCappedUpgradeable {
 
     // =============================================================
     //                         CONSTANTS
     // =============================================================
 
-    /// @notice The TokenManager contract that controls this token
-    address public constant tokenManager = Predeploys.TOKEN_MANAGER;
+    /// @notice The FixedFungible protocol handler that controls this token
+    address public constant protocolHandler = Predeploys.FIXED_FUNGIBLE_HANDLER;
 
     // =============================================================
     //                      STATE VARIABLES
@@ -27,16 +27,16 @@ contract EthscriptionsERC20 is ERC20NullOwnerCappedUpgradeable {
     //                      CUSTOM ERRORS
     // =============================================================
 
-    error OnlyTokenManager();
+    error OnlyProtocolHandler();
     error TransfersOnlyViaEthscriptions();
     error ApprovalsNotAllowed();
 
     // =============================================================
     //                         MODIFIERS
     // =============================================================
 
-    modifier onlyTokenManager() {
-        if (msg.sender != tokenManager) revert OnlyTokenManager();
+    modifier onlyProtocolHandler() {
+        if (msg.sender != protocolHandler) revert OnlyProtocolHandler();
         _;
     }
 
@@ -60,20 +60,20 @@ contract EthscriptionsERC20 is ERC20NullOwnerCappedUpgradeable {
         deployEthscriptionId = deployEthscriptionId_;
     }
 
-    /// @notice Mint tokens (TokenManager only)
+    /// @notice Mint tokens (protocol handler only)
     /// @dev Allows minting to address(0) for null ownership
     /// @param to The recipient address (can be address(0))
     /// @param amount The amount to mint (in 18 decimals)
-    function mint(address to, uint256 amount) external onlyTokenManager {
+    function mint(address to, uint256 amount) external onlyProtocolHandler {
         _mint(to, amount);
     }
 
-    /// @notice Force transfer tokens (TokenManager only)
+    /// @notice Force transfer tokens (protocol handler only)
     /// @dev Allows transfers to/from address(0) for null ownership
     /// @param from The sender address (can be address(0))
     /// @param to The recipient address (can be address(0))
     /// @param amount The amount to transfer (in 18 decimals)
-    function forceTransfer(address from, address to, uint256 amount) external onlyTokenManager {
+    function forceTransfer(address from, address to, uint256 amount) external onlyProtocolHandler {
         _update(from, to, amount);
     }
 
@@ -94,7 +94,7 @@ contract EthscriptionsERC20 is ERC20NullOwnerCappedUpgradeable {
     }
 
     /// @notice Approvals are disabled
-    /// @dev All transfers are controlled by the TokenManager
+    /// @dev All transfers are controlled by the FixedFungibleProtocolHandler
     function approve(address, uint256) public pure override returns (bool) {
         revert ApprovalsNotAllowed();
     }