Merge pull request #130 from ethscriptions-protocol/rename

Big rename

Author: RogerPodacter

…fixed_fungible_token_params_extractor.rb …odels/erc20_fixed_denomination_parser.rbapp/models/fixed_fungible_token_params_extractor.rb renamed to app/models/erc20_fixed_denomination_parser.rb app/models/fixed_fungible_token_params_extractor.rb renamed to app/models/erc20_fixed_denomination_parser.rb

@@ -1,15 +1,14 @@
-# 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 FixedFungibleTokenParamsExtractor
+# Extracts fixed-denomination ERC-20 parameters from strict JSON inscriptions.
+class Erc20FixedDenominationParser
   # 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" or "fixed-fungible" (case-sensitive)
+  # Protocol must be "erc-20" (legacy inscription) or the canonical identifier
   # Tick must be lowercase letters/numbers, max 28 chars
   # Numbers must be positive decimals without leading zeros
-  PROTOCOL_PATTERN = '(?:erc-20|fixed-fungible)'
+  PROTOCOL_PATTERN = '(?:erc-20|erc-20-fixed-denomination)'
   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/
 
@@ -25,7 +24,7 @@ def self.extract(content_uri)
       # Validate uint256 bounds
       return DEFAULT_PARAMS if max > UINT256_MAX || lim > UINT256_MAX
 
-      return ['deploy'.b, 'fixed-fungible'.b, tick.b, max, lim, 0]
+      return ['deploy'.b, 'erc-20-fixed-denomination'.b, tick.b, max, lim, 0]
     end
 
     # Try mint format
@@ -37,7 +36,7 @@ def self.extract(content_uri)
       # Validate uint256 bounds
       return DEFAULT_PARAMS if id > UINT256_MAX || amt > UINT256_MAX
 
-      return ['mint'.b, 'fixed-fungible'.b, tick.b, id, 0, amt]
+      return ['mint'.b, 'erc-20-fixed-denomination'.b, tick.b, id, 0, amt]
     end
 
     # No match - return default

…p/models/collections_params_extractor.rb …rc721_ethscriptions_collection_parser.rbapp/models/collections_params_extractor.rb renamed to app/models/erc721_ethscriptions_collection_parser.rb app/models/collections_params_extractor.rb renamed to app/models/erc721_ethscriptions_collection_parser.rb

@@ -1,5 +1,5 @@
-# Strict extractor for Collections protocol with canonical JSON validation
-class CollectionsParamsExtractor
+# Strict extractor for the ERC-721 Ethscriptions collection protocol with canonical JSON validation
+class Erc721EthscriptionsCollectionParser
   # Default return for invalid input
   DEFAULT_PARAMS = [''.b, ''.b, ''.b].freeze
 
@@ -114,7 +114,7 @@ def extract(content_uri)
       return DEFAULT_PARAMS unless data.is_a?(Hash)
 
       # Check protocol
-      return DEFAULT_PARAMS unless data['p'] == 'collections'
+      return DEFAULT_PARAMS unless data['p'] == 'erc-721-ethscriptions-collection'
 
       # Get operation
       operation = data['op']
@@ -131,7 +131,7 @@ def extract(content_uri)
       # Validate field types and encode
       encoded_data = encode_operation(operation, encoding_data, schema)
 
-      ['collections'.b, operation.b, encoded_data.b]
+      ['erc-721-ethscriptions-collection'.b, operation.b, encoded_data.b]
 
     rescue JSON::ParserError, ValidationError => e
       Rails.logger.debug "Collections extraction failed: #{e.message}" if defined?(Rails)

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 fixed-fungible protocol parsing (shared with protocol extractor)
+  # Helper method for fixed-denomination ERC-20 parsing (shared with protocol extractor)
   def self.extract_token_params(content_uri)
     # Use the strict regex-based extractor for token protocol
-    FixedFungibleTokenParamsExtractor.extract(content_uri)
+    Erc20FixedDenominationParser.extract(content_uri)
   end
 end

app/models/protocol_extractor.rb

@@ -1,8 +1,8 @@
 # Unified protocol extractor that delegates to appropriate extractors
 class ProtocolExtractor
   # Default return values to check if extraction succeeded
-  TOKEN_DEFAULT_PARAMS = FixedFungibleTokenParamsExtractor::DEFAULT_PARAMS
-  COLLECTIONS_DEFAULT_PARAMS = CollectionsParamsExtractor::DEFAULT_PARAMS
+  TOKEN_DEFAULT_PARAMS = Erc20FixedDenominationParser::DEFAULT_PARAMS
+  COLLECTIONS_DEFAULT_PARAMS = Erc721EthscriptionsCollectionParser::DEFAULT_PARAMS
   GENERIC_DEFAULT_PARAMS = GenericProtocolExtractor::DEFAULT_PARAMS
 
   def self.extract(content_uri)
@@ -45,15 +45,15 @@ def self.extract(content_uri)
   private
 
   def self.try_token_extractor(content_uri)
-    # FixedFungibleTokenParamsExtractor uses strict regex and returns DEFAULT_PARAMS if no match
+    # Erc20FixedDenominationParser uses strict regex and returns DEFAULT_PARAMS if no match
     # This enforces non-ESIP6 and exact JSON formatting implicitly.
-    params = FixedFungibleTokenParamsExtractor.extract(content_uri)
+    params = Erc20FixedDenominationParser.extract(content_uri)
 
     # Check if extraction succeeded (returns non-default params)
     if params != TOKEN_DEFAULT_PARAMS
       {
-        type: :fixed_fungible,
-        protocol: 'fixed-fungible',
+        type: :erc20_fixed_denomination,
+        protocol: 'erc-20-fixed-denomination',
         operation: params[0], # 'deploy' or 'mint'
         params: params,
         encoded_params: encode_token_params(params)
@@ -64,13 +64,13 @@ def self.try_token_extractor(content_uri)
   end
 
   def self.try_collections_extractor(content_uri)
-    # CollectionsParamsExtractor returns [''.b, ''.b, ''.b] if no match
-    protocol, operation, encoded_data = CollectionsParamsExtractor.extract(content_uri)
+    # Erc721EthscriptionsCollectionParser returns [''.b, ''.b, ''.b] if no match
+    protocol, operation, encoded_data = Erc721EthscriptionsCollectionParser.extract(content_uri)
 
     # Check if extraction succeeded
     if protocol != ''.b && operation != ''.b
       {
-        type: :collections,
+        type: :erc721_ethscriptions_collection,
         protocol: protocol,
         operation: operation,
         params: nil, # Collections doesn't return decoded params
@@ -135,14 +135,14 @@ def self.for_calldata(content_uri)
     if result.nil?
       # No protocol detected - return empty protocol params
       [''.b, ''.b, ''.b]
-    elsif result[:type] == :fixed_fungible
-      # Fixed-fungible protocol - return in ABI-ready format
+    elsif result[:type] == :erc20_fixed_denomination
+      # Fixed denomination ERC-20 protocol - return in ABI-ready format
       protocol = result[:protocol].b
       operation = result[:operation]
       # For tokens, encode the params properly
       encoded_data = encode_token_data(result[:params])
       [protocol, operation, encoded_data]
-    elsif result[:type] == :collections
+    elsif result[:type] == :erc721_ethscriptions_collection
       # Collections protocol - already has encoded data
       [result[:protocol], result[:operation], result[:encoded_params]]
     else
@@ -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 FixedFungibleProtocolHandler's struct definitions!
+    # IMPORTANT: Field order must match ERC20FixedDenominationManager's struct definitions!
     if op == 'deploy'.b
       # DeployOperation struct: tick, maxSupply, mintAmount
       # Our params: tick, max (val1), lim (val2)

app/services/eth_block_importer.rb

@@ -383,15 +383,11 @@ def import_single_block(block_number)
       ValidationJob.perform_later(block_number, l2_block_hashes)
     end
 
-    # Removed noisy per-block timing logs
-
     ImportProfiler.stop("import_single_block")
 
     [imported_ethscriptions_blocks, [eth_block]]
   end
 
-  # Legacy batch import method removed - use import_single_block instead
-  
   def import_next_block
     block_number = next_block_to_import
     import_single_block(block_number)

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.FIXED_FUNGIBLE_HANDLER ||
+                addr == Predeploys.ERC20_FIXED_DENOMINATION_MANAGER ||
                 addr == Predeploys.ETHSCRIPTIONS_PROVER ||
-                addr == Predeploys.COLLECTIONS_PROTOCOL_HANDLER;
+                addr == Predeploys.ERC721_ETHSCRIPTIONS_COLLECTION_MANAGER;
             if (isProxiedContract) {
                 address impl = Predeploys.predeployToCodeNamespace(addr);
                 setImplementation(addr, impl);
             }
         }
 
         // Set implementation code for non-ETHSCRIPTIONS contracts now
-        _setImplementationCodeNamed(Predeploys.FIXED_FUNGIBLE_HANDLER, "FixedFungibleProtocolHandler");
-        _setImplementationCodeNamed(Predeploys.COLLECTIONS_PROTOCOL_HANDLER, "CollectionsProtocolHandler");
+        _setImplementationCodeNamed(Predeploys.ERC20_FIXED_DENOMINATION_MANAGER, "ERC20FixedDenominationManager");
+        _setImplementationCodeNamed(Predeploys.ERC721_ETHSCRIPTIONS_COLLECTION_MANAGER, "ERC721EthscriptionsCollectionManager");
         _setImplementationCodeNamed(Predeploys.ETHSCRIPTIONS_PROVER, "EthscriptionsProver");
         // Templates live directly at their implementation addresses (no proxy wrapping)
-        _setCodeAt(Predeploys.FIXED_FUNGIBLE_TEMPLATE_IMPLEMENTATION, "FixedFungibleERC20");
-        _setCodeAt(Predeploys.COLLECTIONS_TEMPLATE_IMPLEMENTATION, "CollectionsERC721");
+        _setCodeAt(Predeploys.ERC20_FIXED_DENOMINATION_IMPLEMENTATION, "ERC20FixedDenomination");
+        _setCodeAt(Predeploys.ERC721_ETHSCRIPTIONS_COLLECTION_IMPLEMENTATION, "ERC721EthscriptionsCollection");
 
         // 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("fixed-fungible", Predeploys.FIXED_FUNGIBLE_HANDLER);
-        console.log("Registered fixed-fungible protocol handler:", Predeploys.FIXED_FUNGIBLE_HANDLER);
+        ethscriptions.registerProtocol("erc-20-fixed-denomination", Predeploys.ERC20_FIXED_DENOMINATION_MANAGER);
+        console.log("Registered erc-20-fixed-denomination protocol handler:", Predeploys.ERC20_FIXED_DENOMINATION_MANAGER);
 
         // 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 collections protocol handler for collections operations
-            ethscriptions.registerProtocol("collections", Predeploys.COLLECTIONS_PROTOCOL_HANDLER);
-            console.log("Registered collections protocol handler:", Predeploys.COLLECTIONS_PROTOCOL_HANDLER);
+            // Register the collections protocol handler for ERC-721 Ethscriptions collections
+            ethscriptions.registerProtocol("erc-721-ethscriptions-collection", Predeploys.ERC721_ETHSCRIPTIONS_COLLECTION_MANAGER);
+            console.log("Registered erc-721-ethscriptions-collection protocol handler:", Predeploys.ERC721_ETHSCRIPTIONS_COLLECTION_MANAGER);
         } else {
             console.log("Collections protocol not registered (ENABLE_COLLECTIONS=false)");
         }

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

@@ -4,17 +4,17 @@ pragma solidity 0.8.24;
 import "./ERC20NullOwnerCappedUpgradeable.sol";
 import "./libraries/Predeploys.sol";
 
-/// @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 {
+/// @title ERC20FixedDenomination
+/// @notice ERC-20 proxy whose supply is managed in a fixed denomination by the manager contract.
+/// @dev User-initiated transfers/approvals are disabled; only the manager can mutate balances.
+contract ERC20FixedDenomination is ERC20NullOwnerCappedUpgradeable {
 
     // =============================================================
     //                         CONSTANTS
     // =============================================================
 
-    /// @notice The FixedFungible protocol handler that controls this token
-    address public constant protocolHandler = Predeploys.FIXED_FUNGIBLE_HANDLER;
+    /// @notice The manager contract that controls this token
+    address public constant manager = Predeploys.ERC20_FIXED_DENOMINATION_MANAGER;
 
     // =============================================================
     //                      STATE VARIABLES
@@ -27,28 +27,23 @@ contract FixedFungibleERC20 is ERC20NullOwnerCappedUpgradeable {
     //                      CUSTOM ERRORS
     // =============================================================
 
-    error OnlyProtocolHandler();
+    error OnlyManager();
     error TransfersOnlyViaEthscriptions();
     error ApprovalsNotAllowed();
 
     // =============================================================
     //                         MODIFIERS
     // =============================================================
 
-    modifier onlyProtocolHandler() {
-        if (msg.sender != protocolHandler) revert OnlyProtocolHandler();
+    modifier onlyManager() {
+        if (msg.sender != manager) revert OnlyManager();
         _;
     }
 
     // =============================================================
     //                    EXTERNAL FUNCTIONS
     // =============================================================
 
-    /// @notice Initialize the ERC20 token
-    /// @param name_ The token name
-    /// @param symbol_ The token symbol
-    /// @param cap_ The maximum supply cap (in 18 decimals)
-    /// @param deployEthscriptionId_ The ethscription ID that deployed this token
     function initialize(
         string memory name_,
         string memory symbol_,
@@ -60,41 +55,28 @@ contract FixedFungibleERC20 is ERC20NullOwnerCappedUpgradeable {
         deployEthscriptionId = deployEthscriptionId_;
     }
 
-    /// @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 onlyProtocolHandler {
+    /// @notice Mint tokens (manager only)
+    function mint(address to, uint256 amount) external onlyManager {
         _mint(to, amount);
     }
 
-    /// @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 onlyProtocolHandler {
+    /// @notice Force transfer tokens (manager only)
+    function forceTransfer(address from, address to, uint256 amount) external onlyManager {
         _update(from, to, amount);
     }
 
     // =============================================================
     //                DISABLED ERC20 FUNCTIONS
     // =============================================================
 
-    /// @notice User-initiated transfers are disabled
-    /// @dev All transfers must go through the Ethscriptions NFT
     function transfer(address, uint256) public pure override returns (bool) {
         revert TransfersOnlyViaEthscriptions();
     }
 
-    /// @notice User-initiated transfers are disabled
-    /// @dev All transfers must go through the Ethscriptions NFT
     function transferFrom(address, address, uint256) public pure override returns (bool) {
         revert TransfersOnlyViaEthscriptions();
     }
 
-    /// @notice Approvals are disabled
-    /// @dev All transfers are controlled by the FixedFungibleProtocolHandler
     function approve(address, uint256) public pure override returns (bool) {
         revert ApprovalsNotAllowed();
     }