Improve prover setup

Author: RogerPodacter

contracts/src/Ethscriptions.sol

@@ -131,11 +131,6 @@ contract Ethscriptions is ERC721EthscriptionsUpgradeable {
         bytes revertData
     );
 
-    /// @notice Emitted when a prover operation fails but ethscription continues
-    event ProverFailed(
-        bytes32 indexed transactionHash,
-        bytes revertData
-    );
 
 
     /// @notice Modifier to emit pending genesis events on first real creation
@@ -407,12 +402,8 @@ contract Ethscriptions is ERC721EthscriptionsUpgradeable {
             }
         }
 
-        // Use try-catch to prevent prover failures from reverting operations
-        try prover.proveEthscriptionData(txHash) {} catch (bytes memory revertData) {
-            // Proving failed, but the operation should continue
-            // The prover can be called again later if needed
-            emit ProverFailed(txHash, revertData);
-        }
+        // Queue ethscription for batch proving at block boundary
+        prover.queueEthscription(txHash);
     }
 
     /// @notice Get ethscription details (returns struct to avoid stack too deep)

contracts/src/EthscriptionsProver.sol

@@ -6,11 +6,28 @@ import "./TokenManager.sol";
 import "./EthscriptionsERC20.sol";
 import "./L2/L2ToL1MessagePasser.sol";
 import "./libraries/Predeploys.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
 /// @title EthscriptionsProver
 /// @notice Proves Ethscription ownership and token balances to L1 via OP Stack
 /// @dev Uses L2ToL1MessagePasser to send provable messages to L1
 contract EthscriptionsProver {
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+
+    /// @notice Info stored when an ethscription is queued for proving
+    struct QueuedProof {
+        uint256 blockNumber;
+        uint256 blockTimestamp;
+    }
+
+    /// @notice Set of all ethscription transaction hashes queued for proving
+    EnumerableSet.Bytes32Set private queuedEthscriptions;
+
+    /// @notice Mapping from ethscription tx hash to its queued proof info
+    mapping(bytes32 => QueuedProof) private queuedProofInfo;
+
+    /// @notice L1Block contract address for access control
+    address public constant L1_BLOCK = Predeploys.L1_BLOCK_ATTRIBUTES;
     /// @notice L2ToL1MessagePasser predeploy address on OP Stack
     L2ToL1MessagePasser constant L2_TO_L1_MESSAGE_PASSER = 
         L2ToL1MessagePasser(Predeploys.L2_TO_L1_MESSAGE_PASSER);
@@ -60,6 +77,9 @@ contract EthscriptionsProver {
         uint256 indexed l2BlockNumber,
         uint256 l2Timestamp
     );
+
+    /// @notice Emitted when a batch of proofs is flushed
+    event ProofBatchFlushed(uint256 count, uint256 blockNumber);
 
     /// @notice Prove token balance for an address
     /// @param holder The address to prove balance for
@@ -92,20 +112,64 @@ contract EthscriptionsProver {
         emit TokenBalanceProofSent(holder, tokenInfo.tick, block.number, block.timestamp);
     }
 
-    /// @notice Prove ethscription existence and metadata
+    /// @notice Queue an ethscription for proving
+    /// @dev Only callable by the Ethscriptions contract
+    /// @param txHash The transaction hash of the ethscription
+    function queueEthscription(bytes32 txHash) external virtual {
+        require(msg.sender == address(ethscriptions), "Only Ethscriptions contract can queue");
+
+        // Add to the set (deduplicates automatically)
+        if (queuedEthscriptions.add(txHash)) {
+            // Only store info if this is the first time we're queueing this txHash
+            queuedProofInfo[txHash] = QueuedProof({
+                blockNumber: block.number,
+                blockTimestamp: block.timestamp
+            });
+        }
+    }
+
+    /// @notice Flush all queued proofs
+    /// @dev Only callable by the L1Block contract at the start of each new block
+    function flushAllProofs() external {
+        require(msg.sender == L1_BLOCK, "Only L1Block can flush");
+
+        uint256 count = queuedEthscriptions.length();
+
+        // Process and remove each ethscription from the set
+        // We iterate backwards to avoid index shifting during removal
+        for (uint256 i = count; i > 0; i--) {
+            bytes32 txHash = queuedEthscriptions.at(i - 1);
+
+            // Get the stored proof info to know which block this was from
+            QueuedProof memory proofInfo = queuedProofInfo[txHash];
+
+            // Create and send proof for current state with stored block info
+            _createAndSendProof(txHash, proofInfo.blockNumber, proofInfo.blockTimestamp);
+
+            // Clean up: remove from set and delete the proof info
+            queuedEthscriptions.remove(txHash);
+            delete queuedProofInfo[txHash];
+        }
+
+        emit ProofBatchFlushed(count, block.number - 1);
+    }
+
+    /// @notice Internal function to create and send proof for an ethscription
     /// @param ethscriptionTxHash The transaction hash of the ethscription
-    function proveEthscriptionData(bytes32 ethscriptionTxHash) external virtual {
+    /// @param blockNumber The L2 block number being proved
+    /// @param blockTimestamp The timestamp of the L2 block being proved
+    function _createAndSendProof(bytes32 ethscriptionTxHash, uint256 blockNumber, uint256 blockTimestamp) internal {
         // Get ethscription data including previous owner
         Ethscriptions.Ethscription memory etsc = ethscriptions.getEthscription(ethscriptionTxHash);
         address currentOwner = ethscriptions.currentOwner(ethscriptionTxHash);
-        
+
         // Check if it's a token item
         bool isToken = tokenManager.isTokenItem(ethscriptionTxHash);
         uint256 tokenAmount = 0;
         if (isToken) {
             tokenAmount = tokenManager.getTokenAmount(ethscriptionTxHash);
         }
-        
+
         // Create proof struct with previous owner
         EthscriptionDataProof memory proof = EthscriptionDataProof({
             ethscriptionTxHash: ethscriptionTxHash,
@@ -116,14 +180,15 @@ contract EthscriptionsProver {
             ethscriptionNumber: etsc.ethscriptionNumber,
             isToken: isToken,
             tokenAmount: tokenAmount,
-            l2BlockNumber: block.number,
-            l2Timestamp: block.timestamp
+            l2BlockNumber: blockNumber,
+            l2Timestamp: blockTimestamp
         });
-        
+
         // Encode and send to L1 with zero address and gas (only for state recording)
         bytes memory proofData = abi.encode(proof);
         L2_TO_L1_MESSAGE_PASSER.initiateWithdrawal(address(0), 0, proofData);
-        
-        emit EthscriptionDataProofSent(ethscriptionTxHash, block.number, block.timestamp);
+
+        emit EthscriptionDataProofSent(ethscriptionTxHash, blockNumber, blockTimestamp);
     }
+
 }

contracts/src/L2/L1Block.sol

@@ -2,6 +2,11 @@
 pragma solidity 0.8.24;
 
 import { Constants } from "../libraries/Constants.sol";
+import { Predeploys } from "../libraries/Predeploys.sol";
+
+interface IEthscriptionsProver {
+    function flushAllProofs() external;
+}
 
 /// @custom:proxied
 /// @custom:predeploy 0x4200000000000000000000000000000000000015
@@ -64,6 +69,10 @@ contract L1Block {
     ///   8. _hash               L1 blockhash.
     ///   9. _batcherHash        Versioned hash to authenticate batcher by.
     function setL1BlockValuesEcotone() external {
+        // Flush all queued ethscription proofs before updating to new block
+        // Each proof includes its own block number and timestamp from when it was queued
+        IEthscriptionsProver(Predeploys.ETHSCRIPTIONS_PROVER).flushAllProofs();
+
         address depositor = DEPOSITOR_ACCOUNT();
         assembly {
             // Revert if the caller is not the depositor account.

contracts/test/EthscriptionsFailureHandling.t.sol

@@ -54,11 +54,9 @@ contract FailingProver is EthscriptionsProver {
         failMessage = _message;
     }
 
-    function proveEthscriptionData(bytes32 transactionHash) external override {
-        if (shouldFail) {
-            revert(failMessage);
-        }
-        // Otherwise do nothing
+    function queueEthscription(bytes32 txHash) external override {
+        // For testing, always succeed
+        // In the new design, queueing doesn't fail and doesn't emit events
     }
 }
 
@@ -72,11 +70,6 @@ contract EthscriptionsFailureHandlingTest is TestSetup {
         bytes revertData
     );
 
-    event ProverFailed(
-        bytes32 indexed transactionHash,
-        bytes revertData
-    );
-
     function setUp() public override {
         super.setUp();
 
@@ -138,12 +131,12 @@ contract EthscriptionsFailureHandlingTest is TestSetup {
     }
 
     function testCreateEthscriptionWithProverFailure() public {
-        // Configure Prover to fail
-        FailingProver(Predeploys.ETHSCRIPTIONS_PROVER).setShouldFail(true);
-        FailingProver(Predeploys.ETHSCRIPTIONS_PROVER).setFailMessage("Proving failed");
+        // Note: With the new batched proving design, the prover doesn't fail immediately
+        // during creation. Instead, ethscriptions are queued for batch proving.
+        // This test now verifies that creation succeeds and the ethscription is queued.
 
         bytes32 txHash = keccak256("test_tx_2");
-        string memory dataUri = "data:,Hello World with failing prover";
+        string memory dataUri = "data:,Hello World with batched prover";
 
         Ethscriptions.CreateEthscriptionParams memory params = createTestParams(
             txHash,
@@ -152,14 +145,7 @@ contract EthscriptionsFailureHandlingTest is TestSetup {
             false
         );
 
-        // Expect the ProverFailed event
-        vm.expectEmit(true, false, false, true);
-        emit ProverFailed(
-            txHash,
-            abi.encodeWithSignature("Error(string)", "Proving failed")
-        );
-
-        // Create ethscription - should succeed despite Prover failure
+        // Create ethscription - should succeed and queue for proving silently (no event)
         uint256 tokenId = ethscriptions.createEthscription(params);
 
         // Verify the ethscription was created successfully