L1 Oracle Reader — 实现

For Claude: REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.

Goal: Build a trustless L1 contract that reads L2 Oracle prices via era Mailbox proof verification, enabling L1 DApps to query BabyDriver Oracle data.

Architecture: Standalone Sidecar contract (same pattern as Phase 3 FastWithdrawalPoolV2). L2 OracleHub sends prices via L2→L1 messages. Anyone can submit a Merkle proof to L1OracleReader.updatePrice(), which verifies inclusion via IMailbox.proveL2MessageInclusion() and stores the price. Reuses existing IMailbox.sol and MockMailbox.sol from Phase 3.

Tech Stack: Solidity 0.8.26, Foundry (forge), OpenZeppelin ReentrancyGuard, IMailbox (local copy of era Mailbox interface)

---

Existing Files You Need to Know

These files already exist and you will import/reuse them (do NOT recreate):

File	What it does
contracts/src/interfaces/IMailbox.sol	Minimal era Mailbox interface with L2Message struct and proveL2MessageInclusion()
contracts/test/mocks/MockMailbox.sol	Configurable mock: setDefaultResponse(bool) and setProofValid(batchNumber, index, messageHash)
contracts/src/bridge/FastWithdrawalPoolV2.sol	Reference for coding style, import paths, ReentrancyGuard usage, Mailbox interaction pattern

Build & test commands (always run from contracts/ directory):

cd /Users/judybaby/CodeBase/github/Layer2/contracts
forge build      # compile
forge test       # run all tests
forge test --match-contract L1OracleReaderTest -vvv  # run only our tests with verbose

Solidity style conventions (match FastWithdrawalPoolV2):

• SPDX MIT, pragma ^0.8.26

• OpenZeppelin imported as @openzeppelin/contracts/...

• Section separators: // ==================== Section Name ====================

• /// @inheritdoc IInterface on all interface implementations

• Constants: UPPER_SNAKE_CASE, public

• Private storage: _prefixed with underscore

• Immutables: UPPER_SNAKE_CASE, public

• Require strings: short, descriptive English

• Test addresses: hex constants like address(0x1001)

• Test helper functions: _prefixed internal

---

Task 1: Create IL1OracleReader Interface

Files:

• Create: contracts/src/interfaces/IL1OracleReader.sol

Step 1: Write the interface

Create contracts/src/interfaces/IL1OracleReader.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

interface IL1OracleReader {
    struct PriceData {
        uint256 price;
        uint256 timestamp;
        uint256 l2BatchNumber;
    }

    event PriceUpdated(
        bytes32 indexed pairId,
        uint256 price,
        uint256 timestamp,
        uint256 l2BatchNumber,
        address indexed submitter
    );

    /// @notice Submit an L2→L1 message proof to update a price on L1
    /// @param pairId The trading pair identifier (e.g., keccak256("ETH/USD"))
    /// @param l2BatchNumber L2 batch where the Oracle message was sent
    /// @param l2MessageIndex Message index within the batch
    /// @param l2TxNumberInBatch Transaction number within the batch
    /// @param merkleProof Merkle proof of L2→L1 message inclusion
    /// @param message Raw message bytes: abi.encode(pairId, price, timestamp)
    function updatePrice(
        bytes32 pairId,
        uint256 l2BatchNumber,
        uint256 l2MessageIndex,
        uint16 l2TxNumberInBatch,
        bytes32[] calldata merkleProof,
        bytes calldata message
    ) external;

    /// @notice Get the latest price for a trading pair
    /// @return price The price value (18 decimals)
    /// @return timestamp The L2 timestamp when the price was recorded
    function getLatestPrice(bytes32 pairId) external view returns (uint256 price, uint256 timestamp);

    /// @notice Get full price data for a trading pair
    function getPriceData(bytes32 pairId) external view returns (PriceData memory);

    /// @notice Check if a message has already been processed (replay protection)
    function isMessageProcessed(uint256 l2BatchNumber, uint256 l2MessageIndex) external view returns (bool);
}

Step 2: Verify it compiles

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge build Expected: Compilation success (interface-only, no dependencies beyond Solidity)

Step 3: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/src/interfaces/IL1OracleReader.sol
git commit -m "feat(oracle): add IL1OracleReader interface for L1 price reading"

---

Task 2: Create L1OracleReader Contract Skeleton + Constructor Tests

Files:

• Create: contracts/src/oracle/L1OracleReader.sol

• Create: contracts/test/L1OracleReader.t.sol

Step 1: Write the failing tests

Create contracts/test/L1OracleReader.t.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

import "forge-std/Test.sol";
import "../src/oracle/L1OracleReader.sol";
import "./mocks/MockMailbox.sol";

contract L1OracleReaderTest is Test {
    L1OracleReader public reader;
    MockMailbox public mockMailbox;

    // L2 OracleHub system contract address
    address constant L2_ORACLE_HUB = address(0x8016);

    address submitter1 = address(0x2001);
    address submitter2 = address(0x2002);

    bytes32 constant PAIR_ETH_USD = keccak256("ETH/USD");
    bytes32 constant PAIR_BTC_USD = keccak256("BTC/USD");

    function setUp() public {
        mockMailbox = new MockMailbox(false);
        reader = new L1OracleReader(address(mockMailbox), L2_ORACLE_HUB);
    }

    // ==================== Constructor (3 tests) ====================

    function test_constructor_setsMailbox() public view {
        assertEq(address(reader.MAILBOX()), address(mockMailbox));
    }

    function test_constructor_setsL2OracleHub() public view {
        assertEq(reader.L2_ORACLE_HUB(), L2_ORACLE_HUB);
    }

    function test_constructor_revertZeroMailbox() public {
        vm.expectRevert("Mailbox cannot be zero");
        new L1OracleReader(address(0), L2_ORACLE_HUB);
    }

    function test_constructor_revertZeroOracleHub() public {
        vm.expectRevert("L2 OracleHub cannot be zero");
        new L1OracleReader(address(mockMailbox), address(0));
    }
}

Step 2: Run tests to verify they fail

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract L1OracleReaderTest -vvv Expected: FAIL — L1OracleReader does not exist yet

Step 3: Write minimal L1OracleReader skeleton

Create contracts/src/oracle/L1OracleReader.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "../interfaces/IL1OracleReader.sol";
import "../interfaces/IMailbox.sol";

/**
 * @title L1OracleReader
 * @notice Reads L2 Oracle prices on L1 via era Mailbox proof verification.
 *         Anyone can submit a valid L2→L1 message proof to update prices.
 *         Sidecar pattern — zero modifications to era-contracts.
 *
 *         Flow:
 *         1. L2 OracleHub (0x8016) sends price via L2→L1 message
 *         2. Batch is committed and proven on L1
 *         3. Anyone calls updatePrice() with Merkle proof
 *         4. Contract verifies proof via Mailbox, stores price
 *         5. L1 DApps call getLatestPrice() to read
 */
contract L1OracleReader is IL1OracleReader, ReentrancyGuard {
    // ==================== Immutables ====================

    IMailbox public immutable MAILBOX;
    address public immutable L2_ORACLE_HUB;

    // ==================== Storage ====================

    // pairId => latest price data
    mapping(bytes32 => PriceData) private _prices;

    // replay protection: keccak256(l2BatchNumber, l2MessageIndex) => processed
    mapping(bytes32 => bool) private _processedMessages;

    // ==================== Constructor ====================

    constructor(address mailbox, address l2OracleHub) {
        require(mailbox != address(0), "Mailbox cannot be zero");
        require(l2OracleHub != address(0), "L2 OracleHub cannot be zero");
        MAILBOX = IMailbox(mailbox);
        L2_ORACLE_HUB = l2OracleHub;
    }

    // ==================== Price Update ====================

    /// @inheritdoc IL1OracleReader
    function updatePrice(
        bytes32 pairId,
        uint256 l2BatchNumber,
        uint256 l2MessageIndex,
        uint16 l2TxNumberInBatch,
        bytes32[] calldata merkleProof,
        bytes calldata message
    ) external nonReentrant {
        // TODO: implement in Task 3
        revert("Not implemented");
    }

    // ==================== View ====================

    /// @inheritdoc IL1OracleReader
    function getLatestPrice(bytes32 pairId) external view returns (uint256 price, uint256 timestamp) {
        PriceData memory data = _prices[pairId];
        return (data.price, data.timestamp);
    }

    /// @inheritdoc IL1OracleReader
    function getPriceData(bytes32 pairId) external view returns (PriceData memory) {
        return _prices[pairId];
    }

    /// @inheritdoc IL1OracleReader
    function isMessageProcessed(uint256 l2BatchNumber, uint256 l2MessageIndex) external view returns (bool) {
        bytes32 key = keccak256(abi.encode(l2BatchNumber, l2MessageIndex));
        return _processedMessages[key];
    }
}

Step 4: Run tests to verify they pass

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract L1OracleReaderTest -vvv Expected: 4 tests PASS

Step 5: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/src/oracle/L1OracleReader.sol contracts/test/L1OracleReader.t.sol
git commit -m "feat(oracle): L1OracleReader skeleton + constructor tests"

---

Task 3: Implement updatePrice Core Logic (TDD)

Files:

• Modify: contracts/src/oracle/L1OracleReader.sol (replace updatePrice stub)

• Modify: contracts/test/L1OracleReader.t.sol (add updatePrice tests)

Step 1: Write the failing tests

Add these tests to contracts/test/L1OracleReader.t.sol inside the L1OracleReaderTest contract, after the constructor tests:

    // ==================== Helper ====================

    /// @notice Encode an Oracle price message (matches L2 OracleHub format)
    function _encodeMessage(bytes32 pairId, uint256 price, uint256 timestamp) internal pure returns (bytes memory) {
        return abi.encode(pairId, price, timestamp);
    }

    // ==================== updatePrice — success (4 tests) ====================

    function test_updatePrice_validProof() public {
        mockMailbox.setDefaultResponse(true);

        bytes memory message = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);

        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), message);

        (uint256 price, uint256 timestamp) = reader.getLatestPrice(PAIR_ETH_USD);
        assertEq(price, 3000e18);
        assertEq(timestamp, 1000);
    }

    function test_updatePrice_emitsEvent() public {
        mockMailbox.setDefaultResponse(true);

        bytes memory message = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);

        vm.expectEmit(true, true, true, true);
        emit IL1OracleReader.PriceUpdated(PAIR_ETH_USD, 3000e18, 1000, 100, submitter1);

        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), message);
    }

    function test_updatePrice_storesPriceData() public {
        mockMailbox.setDefaultResponse(true);

        bytes memory message = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);

        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), message);

        IL1OracleReader.PriceData memory data = reader.getPriceData(PAIR_ETH_USD);
        assertEq(data.price, 3000e18);
        assertEq(data.timestamp, 1000);
        assertEq(data.l2BatchNumber, 100);
    }

    function test_updatePrice_marksMessageProcessed() public {
        mockMailbox.setDefaultResponse(true);

        bytes memory message = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);

        assertFalse(reader.isMessageProcessed(100, 0));

        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), message);

        assertTrue(reader.isMessageProcessed(100, 0));
    }

    // ==================== updatePrice — reverts (5 tests) ====================

    function test_updatePrice_revertInvalidProof() public {
        // MockMailbox default is false — proof verification fails
        bytes memory message = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);

        vm.prank(submitter1);
        vm.expectRevert("Invalid L2 message proof");
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), message);
    }

    function test_updatePrice_revertReplay() public {
        mockMailbox.setDefaultResponse(true);

        bytes memory message = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);

        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), message);

        // Same batch + index = replay
        vm.prank(submitter2);
        vm.expectRevert("Message already processed");
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), message);
    }

    function test_updatePrice_revertZeroPrice() public {
        mockMailbox.setDefaultResponse(true);

        bytes memory message = _encodeMessage(PAIR_ETH_USD, 0, 1000);

        vm.prank(submitter1);
        vm.expectRevert("Price must be > 0");
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), message);
    }

    function test_updatePrice_revertStalePrice() public {
        mockMailbox.setDefaultResponse(true);

        // First update at timestamp 2000
        bytes memory msg1 = _encodeMessage(PAIR_ETH_USD, 3000e18, 2000);
        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), msg1);

        // Second update with older timestamp 1000 — should revert
        bytes memory msg2 = _encodeMessage(PAIR_ETH_USD, 2900e18, 1000);
        vm.prank(submitter2);
        vm.expectRevert("Price is not newer");
        reader.updatePrice(PAIR_ETH_USD, 101, 0, 1, new bytes32[](0), msg2);
    }

    function test_updatePrice_revertPairIdMismatch() public {
        mockMailbox.setDefaultResponse(true);

        // Message contains BTC/USD but caller says ETH/USD
        bytes memory message = _encodeMessage(PAIR_BTC_USD, 60000e18, 1000);

        vm.prank(submitter1);
        vm.expectRevert("PairId mismatch");
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), message);
    }

Step 2: Run tests to verify they fail

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract L1OracleReaderTest -vvv Expected: 9 new tests FAIL (updatePrice still reverts "Not implemented")

Step 3: Implement updatePrice

Replace the updatePrice function in contracts/src/oracle/L1OracleReader.sol:

    /// @inheritdoc IL1OracleReader
    function updatePrice(
        bytes32 pairId,
        uint256 l2BatchNumber,
        uint256 l2MessageIndex,
        uint16 l2TxNumberInBatch,
        bytes32[] calldata merkleProof,
        bytes calldata message
    ) external nonReentrant {
        // 1. Replay protection
        bytes32 messageKey = keccak256(abi.encode(l2BatchNumber, l2MessageIndex));
        require(!_processedMessages[messageKey], "Message already processed");

        // 2. Verify L2→L1 message proof via era Mailbox
        IMailbox.L2Message memory l2Message = IMailbox.L2Message({
            txNumberInBatch: l2TxNumberInBatch,
            sender: L2_ORACLE_HUB,
            data: message
        });

        bool valid = MAILBOX.proveL2MessageInclusion(l2BatchNumber, l2MessageIndex, l2Message, merkleProof);
        require(valid, "Invalid L2 message proof");

        // 3. Decode message
        (bytes32 decodedPairId, uint256 price, uint256 timestamp) = abi.decode(message, (bytes32, uint256, uint256));

        // 4. Validate
        require(decodedPairId == pairId, "PairId mismatch");
        require(price > 0, "Price must be > 0");
        require(timestamp > _prices[pairId].timestamp, "Price is not newer");

        // 5. Store
        _processedMessages[messageKey] = true;
        _prices[pairId] = PriceData({
            price: price,
            timestamp: timestamp,
            l2BatchNumber: l2BatchNumber
        });

        emit PriceUpdated(pairId, price, timestamp, l2BatchNumber, msg.sender);
    }

Step 4: Run tests to verify they pass

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract L1OracleReaderTest -vvv Expected: All 13 tests PASS

Step 5: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/src/oracle/L1OracleReader.sol contracts/test/L1OracleReader.t.sol
git commit -m "feat(oracle): implement L1OracleReader.updatePrice with proof verification"

---

Task 4: Multiple Pairs + Update Sequencing Tests (TDD)

Files:

• Modify: contracts/test/L1OracleReader.t.sol (add multi-pair and sequencing tests)

Step 1: Write the tests

Add these tests to contracts/test/L1OracleReader.t.sol:

    // ==================== Multiple Pairs (3 tests) ====================

    function test_updatePrice_multiplePairsIndependent() public {
        mockMailbox.setDefaultResponse(true);

        bytes memory ethMsg = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);
        bytes memory btcMsg = _encodeMessage(PAIR_BTC_USD, 60000e18, 1000);

        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), ethMsg);

        vm.prank(submitter1);
        reader.updatePrice(PAIR_BTC_USD, 100, 1, 2, new bytes32[](0), btcMsg);

        (uint256 ethPrice,) = reader.getLatestPrice(PAIR_ETH_USD);
        (uint256 btcPrice,) = reader.getLatestPrice(PAIR_BTC_USD);
        assertEq(ethPrice, 3000e18);
        assertEq(btcPrice, 60000e18);
    }

    function test_updatePrice_newerPriceOverwrites() public {
        mockMailbox.setDefaultResponse(true);

        // First price
        bytes memory msg1 = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);
        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), msg1);

        // Newer price (different batch + index, newer timestamp)
        bytes memory msg2 = _encodeMessage(PAIR_ETH_USD, 3100e18, 2000);
        vm.prank(submitter2);
        reader.updatePrice(PAIR_ETH_USD, 101, 0, 1, new bytes32[](0), msg2);

        (uint256 price, uint256 timestamp) = reader.getLatestPrice(PAIR_ETH_USD);
        assertEq(price, 3100e18);
        assertEq(timestamp, 2000);

        // Batch number also updated
        IL1OracleReader.PriceData memory data = reader.getPriceData(PAIR_ETH_USD);
        assertEq(data.l2BatchNumber, 101);
    }

    function test_getLatestPrice_uninitializedReturnsZero() public view {
        (uint256 price, uint256 timestamp) = reader.getLatestPrice(PAIR_ETH_USD);
        assertEq(price, 0);
        assertEq(timestamp, 0);
    }

    // ==================== Anyone Can Submit (2 tests) ====================

    function test_updatePrice_anyoneCanSubmit() public {
        mockMailbox.setDefaultResponse(true);

        bytes memory message = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);

        // submitter1 updates
        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), message);

        (uint256 price,) = reader.getLatestPrice(PAIR_ETH_USD);
        assertEq(price, 3000e18);

        // submitter2 updates with newer data (different batch)
        bytes memory msg2 = _encodeMessage(PAIR_ETH_USD, 3100e18, 2000);
        vm.prank(submitter2);
        reader.updatePrice(PAIR_ETH_USD, 101, 0, 1, new bytes32[](0), msg2);

        (price,) = reader.getLatestPrice(PAIR_ETH_USD);
        assertEq(price, 3100e18);
    }

    function test_updatePrice_sameBatchDifferentIndexAllowed() public {
        mockMailbox.setDefaultResponse(true);

        bytes memory ethMsg = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);
        bytes memory btcMsg = _encodeMessage(PAIR_BTC_USD, 60000e18, 1001);

        // Same batch (100), different message index (0 vs 1) — both allowed
        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), ethMsg);

        vm.prank(submitter1);
        reader.updatePrice(PAIR_BTC_USD, 100, 1, 2, new bytes32[](0), btcMsg);

        assertTrue(reader.isMessageProcessed(100, 0));
        assertTrue(reader.isMessageProcessed(100, 1));
    }

Step 2: Run tests to verify they pass

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract L1OracleReaderTest -vvv Expected: All 18 tests PASS (these test existing functionality, should pass immediately)

Step 3: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/test/L1OracleReader.t.sol
git commit -m "test(oracle): add multi-pair and submission tests for L1OracleReader"

---

Task 5: E2E Lifecycle Test

Files:

• Modify: contracts/test/L1OracleReader.t.sol (add E2E test)

Step 1: Write the E2E test

Add this test to contracts/test/L1OracleReader.t.sol:

    // ==================== E2E Lifecycle (1 test) ====================

    function test_E2E_oraclePriceLifecycle() public {
        mockMailbox.setDefaultResponse(true);

        // 1. Initially no prices
        (uint256 price, uint256 ts) = reader.getLatestPrice(PAIR_ETH_USD);
        assertEq(price, 0);
        assertEq(ts, 0);

        // 2. Batch 100: ETH/USD = $3000, BTC/USD = $60000
        bytes memory ethMsg1 = _encodeMessage(PAIR_ETH_USD, 3000e18, 1000);
        bytes memory btcMsg1 = _encodeMessage(PAIR_BTC_USD, 60000e18, 1000);

        vm.prank(submitter1);
        reader.updatePrice(PAIR_ETH_USD, 100, 0, 1, new bytes32[](0), ethMsg1);
        vm.prank(submitter1);
        reader.updatePrice(PAIR_BTC_USD, 100, 1, 2, new bytes32[](0), btcMsg1);

        (price, ts) = reader.getLatestPrice(PAIR_ETH_USD);
        assertEq(price, 3000e18);
        assertEq(ts, 1000);

        // 3. Batch 101: ETH/USD updates to $3100 (price movement)
        bytes memory ethMsg2 = _encodeMessage(PAIR_ETH_USD, 3100e18, 2000);
        vm.prank(submitter2);
        reader.updatePrice(PAIR_ETH_USD, 101, 0, 1, new bytes32[](0), ethMsg2);

        (price, ts) = reader.getLatestPrice(PAIR_ETH_USD);
        assertEq(price, 3100e18);
        assertEq(ts, 2000);

        // BTC still at old price (not updated this batch)
        (price,) = reader.getLatestPrice(PAIR_BTC_USD);
        assertEq(price, 60000e18);

        // 4. Verify batch numbers tracked correctly
        IL1OracleReader.PriceData memory ethData = reader.getPriceData(PAIR_ETH_USD);
        assertEq(ethData.l2BatchNumber, 101);
        IL1OracleReader.PriceData memory btcData = reader.getPriceData(PAIR_BTC_USD);
        assertEq(btcData.l2BatchNumber, 100);

        // 5. Verify replay protection
        assertTrue(reader.isMessageProcessed(100, 0));
        assertTrue(reader.isMessageProcessed(100, 1));
        assertTrue(reader.isMessageProcessed(101, 0));
        assertFalse(reader.isMessageProcessed(101, 1)); // not used
    }

Step 2: Run tests to verify they pass

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract L1OracleReaderTest -vvv Expected: All 19 tests PASS

Step 3: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/test/L1OracleReader.t.sol
git commit -m "test(oracle): add E2E lifecycle test for L1OracleReader"

---

Task 6: Full Test Suite Verification

Files: None modified — verification only

Step 1: Run the full project test suite

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test -vv Expected: ALL tests pass (existing 114 + new 19 = 133 total, approximately)

Check that:

• All L1OracleReaderTest tests pass (19)

• All FastWithdrawalPoolV2Test tests pass (31)

• All Bridge.t.sol tests pass

• All E2E.t.sol tests pass

• No regressions

Step 2: Run forge build to confirm clean compilation

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge build Expected: Compilation success, no errors

Step 3: Final commit if any cleanup needed

If all tests pass with no changes needed, skip this step.

---

Summary

Task	Tests	Commit Message
1	0	feat(oracle): add IL1OracleReader interface
2	4	feat(oracle): L1OracleReader skeleton + constructor tests
3	13	feat(oracle): implement updatePrice with proof verification
4	18	test(oracle): add multi-pair and submission tests
5	19	test(oracle): add E2E lifecycle test
6	19 (verify all 133)	(verification only)

Total: 6 tasks, 19 new tests, ~5 commits