From 7273464f6965eddf92fda22b6acc05867a83de5d Mon Sep 17 00:00:00 2001 From: Pepe Blasco Date: Tue, 10 Feb 2026 10:47:14 +0100 Subject: [PATCH] constants not using UPPER_CASE format --- .../provers/arbitrum/ChildToParentProver.sol | 22 ++++++------ .../provers/arbitrum/ParentToChildProver.sol | 22 ++++++------ .../provers/linea/ChildToParentProver.sol | 24 ++++++------- .../provers/linea/ParentToChildProver.sol | 22 ++++++------ .../provers/optimism/ChildToParentProver.sol | 16 ++++----- .../provers/optimism/ParentToChildProver.sol | 16 ++++----- .../provers/scroll/ChildToParentProver.sol | 24 ++++++------- .../provers/scroll/ParentToChildProver.sol | 24 ++++++------- .../provers/taiko/ChildToParentProver.sol | 24 ++++++------- .../provers/taiko/ParentToChildProver.sol | 24 ++++++------- .../provers/zksync/ChildToParentProver.sol | 24 ++++++------- .../provers/zksync/ParentToChildProver.sol | 34 +++++++++---------- test/Receiver.t.sol | 10 +++--- test/VerifyBroadcastMessageBenchmark.t.sol | 4 +-- test/provers/linea/ParentToChildProver.t.sol | 18 +++++----- test/provers/scroll/ParentToChildProver.t.sol | 6 ++-- test/provers/taiko/ChildToParentProver.t.sol | 12 +++---- test/provers/taiko/ParentToChildProver.t.sol | 18 +++++----- 18 files changed, 172 insertions(+), 172 deletions(-) diff --git a/src/contracts/provers/arbitrum/ChildToParentProver.sol b/src/contracts/provers/arbitrum/ChildToParentProver.sol index 6434549..104e452 100644 --- a/src/contracts/provers/arbitrum/ChildToParentProver.sol +++ b/src/contracts/provers/arbitrum/ChildToParentProver.sol @@ -13,22 +13,22 @@ import {SlotDerivation} from "@openzeppelin/contracts/utils/SlotDerivation.sol"; contract ChildToParentProver is IStateProver { /// @dev Address of the block hash buffer contract /// See https://github.com/OffchainLabs/block-hash-pusher/blob/a1e26f2e42e6306d1e7f03c5d20fa6aa64ff7a12/.env.example#L12 - address public constant blockHashBuffer = 0x0000000048C4Ed10cF14A02B9E0AbDDA5227b071; + address public constant BLOCK_HASH_BUFFER = 0x0000000048C4Ed10cF14A02B9E0AbDDA5227b071; /// @dev Storage slot the buffer contract uses to store block hashes. /// See https://github.com/OffchainLabs/block-hash-pusher/blob/a1e26f2e42e6306d1e7f03c5d20fa6aa64ff7a12/contracts/Buffer.sol#L32 - uint256 public constant blockHashMappingSlot = 51; + uint256 public constant BLOCK_HASH_MAPPING_SLOT = 51; /// @dev The chain Id of the home chain, i.e., the child chain. - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); constructor(uint256 _homeChainId) { - homeChainId = _homeChainId; + HOME_CHAIN_ID = _homeChainId; } - /// @notice Get a parent chain block hash from the buffer at `blockHashBuffer` using a storage proof + /// @notice Get a parent chain block hash from the buffer at `BLOCK_HASH_BUFFER` using a storage proof /// @param homeBlockHash The block hash of the home chain. /// @param input ABI encoded (bytes blockHeader, uint256 targetBlockNumber, bytes accountProof, bytes storageProof) function verifyTargetStateCommitment(bytes32 homeBlockHash, bytes calldata input) @@ -36,7 +36,7 @@ contract ChildToParentProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } // decode the input @@ -45,25 +45,25 @@ contract ChildToParentProver is IStateProver { // calculate the slot based on the provided block number // see: https://github.com/OffchainLabs/block-hash-pusher/blob/a1e26f2e42e6306d1e7f03c5d20fa6aa64ff7a12/contracts/Buffer.sol#L32 - uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(blockHashMappingSlot), targetBlockNumber)); + uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(BLOCK_HASH_MAPPING_SLOT), targetBlockNumber)); // verify proofs and get the block hash targetStateCommitment = ProverUtils.getSlotFromBlockHeader( - homeBlockHash, rlpBlockHeader, blockHashBuffer, slot, accountProof, storageProof + homeBlockHash, rlpBlockHeader, BLOCK_HASH_BUFFER, slot, accountProof, storageProof ); } - /// @notice Get a parent chain block hash from the buffer at `blockHashBuffer`. + /// @notice Get a parent chain block hash from the buffer at `BLOCK_HASH_BUFFER`. /// @param input ABI encoded (uint256 targetBlockNumber) function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } //decode the input uint256 targetBlockNumber = abi.decode(input, (uint256)); // get the block hash from the buffer - targetStateCommitment = IBuffer(blockHashBuffer).parentChainBlockHash(targetBlockNumber); + targetStateCommitment = IBuffer(BLOCK_HASH_BUFFER).parentChainBlockHash(targetBlockNumber); } /// @notice Verify a storage slot given a target chain block hash and a proof. diff --git a/src/contracts/provers/arbitrum/ParentToChildProver.sol b/src/contracts/provers/arbitrum/ParentToChildProver.sol index 66caaf2..fd2ae9e 100644 --- a/src/contracts/provers/arbitrum/ParentToChildProver.sol +++ b/src/contracts/provers/arbitrum/ParentToChildProver.sol @@ -11,23 +11,23 @@ import {SlotDerivation} from "@openzeppelin/contracts/utils/SlotDerivation.sol"; /// verifyStorageSlot is implemented to work against any Arbitrum child chain with a standard Ethereum block header and state trie. contract ParentToChildProver is IStateProver { /// @dev Address of the child chain's Outbox contract - address public immutable outbox; + address public immutable OUTBOX; /// @dev Storage slot the Outbox contract uses to store roots. /// Should be set to 3 unless the outbox contract has been modified. /// See https://github.com/OffchainLabs/nitro-contracts/blob/9d0e90ef588f94a9d2ffa4dc22713d91a76f57d4/src/bridge/AbsOutbox.sol#L32 - uint256 public immutable rootsSlot; + uint256 public immutable ROOTS_SLOT; /// @dev The chain ID of the home chain (where this prover reads from). - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); error TargetBlockHashNotFound(); constructor(address _outbox, uint256 _rootsSlot, uint256 _homeChainId) { - outbox = _outbox; - rootsSlot = _rootsSlot; - homeChainId = _homeChainId; + OUTBOX = _outbox; + ROOTS_SLOT = _rootsSlot; + HOME_CHAIN_ID = _homeChainId; } /// @notice Verify a target chain block hash given a home chain block hash and a proof. @@ -38,7 +38,7 @@ contract ParentToChildProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } @@ -48,11 +48,11 @@ contract ParentToChildProver is IStateProver { // calculate the slot based on the provided send root // see: https://github.com/OffchainLabs/nitro-contracts/blob/9d0e90ef588f94a9d2ffa4dc22713d91a76f57d4/src/bridge/AbsOutbox.sol#L32 - uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(rootsSlot), sendRoot)); + uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(ROOTS_SLOT), sendRoot)); // verify proofs and get the block hash targetStateCommitment = - ProverUtils.getSlotFromBlockHeader(homeBlockHash, rlpBlockHeader, outbox, slot, accountProof, storageProof); + ProverUtils.getSlotFromBlockHeader(homeBlockHash, rlpBlockHeader, OUTBOX, slot, accountProof, storageProof); if (targetStateCommitment == bytes32(0)) { revert TargetBlockHashNotFound(); @@ -62,14 +62,14 @@ contract ParentToChildProver is IStateProver { /// @notice Get a target chain block hash given a target chain sendRoot /// @param input ABI encoded (bytes32 sendRoot) function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } // decode the input bytes32 sendRoot = abi.decode(input, (bytes32)); // get the target block hash from the outbox - targetStateCommitment = IOutbox(outbox).roots(sendRoot); + targetStateCommitment = IOutbox(OUTBOX).roots(sendRoot); if (targetStateCommitment == bytes32(0)) { revert TargetBlockHashNotFound(); diff --git a/src/contracts/provers/linea/ChildToParentProver.sol b/src/contracts/provers/linea/ChildToParentProver.sol index fd32bf3..fd13aa1 100644 --- a/src/contracts/provers/linea/ChildToParentProver.sol +++ b/src/contracts/provers/linea/ChildToParentProver.sol @@ -11,23 +11,23 @@ import {SlotDerivation} from "@openzeppelin/contracts/utils/SlotDerivation.sol"; /// verifyStorageSlot is implemented to work against any parent chain with a standard Ethereum block header and state trie. contract ChildToParentProver is IStateProver { /// @dev Address of the block hash buffer contract. - address public immutable blockHashBuffer; + address public immutable BLOCK_HASH_BUFFER; /// @dev Storage slot the buffer contract uses to store block hashes. /// See https://github.com/openintentsframework/broadcaster/blob/main/src/contracts/block-hash-pusher/BaseBuffer.sol - uint256 public constant blockHashMappingSlot = 1; + uint256 public constant BLOCK_HASH_MAPPING_SLOT = 1; /// @dev The chain ID of the home chain (child chain). - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); constructor(address _blockHashBuffer, uint256 _homeChainId) { - blockHashBuffer = _blockHashBuffer; - homeChainId = _homeChainId; + BLOCK_HASH_BUFFER = _blockHashBuffer; + HOME_CHAIN_ID = _homeChainId; } - /// @notice Get a parent chain block hash from the buffer at `blockHashBuffer` using a storage proof + /// @notice Get a parent chain block hash from the buffer at `BLOCK_HASH_BUFFER` using a storage proof /// @param homeBlockHash The block hash of the home chain. /// @param input ABI encoded (bytes blockHeader, uint256 targetBlockNumber, bytes accountProof, bytes storageProof) function verifyTargetStateCommitment(bytes32 homeBlockHash, bytes calldata input) @@ -35,7 +35,7 @@ contract ChildToParentProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } // decode the input @@ -44,25 +44,25 @@ contract ChildToParentProver is IStateProver { // calculate the slot based on the provided block number // see: https://github.com/OffchainLabs/block-hash-pusher/blob/a1e26f2e42e6306d1e7f03c5d20fa6aa64ff7a12/contracts/Buffer.sol#L32 - uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(blockHashMappingSlot), targetBlockNumber)); + uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(BLOCK_HASH_MAPPING_SLOT), targetBlockNumber)); // verify proofs and get the block hash targetStateCommitment = ProverUtils.getSlotFromBlockHeader( - homeBlockHash, rlpBlockHeader, blockHashBuffer, slot, accountProof, storageProof + homeBlockHash, rlpBlockHeader, BLOCK_HASH_BUFFER, slot, accountProof, storageProof ); } - /// @notice Get a parent chain block hash from the buffer at `blockHashBuffer`. + /// @notice Get a parent chain block hash from the buffer at `BLOCK_HASH_BUFFER`. /// @param input ABI encoded (uint256 targetBlockNumber) function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } // decode the input uint256 targetBlockNumber = abi.decode(input, (uint256)); // get the block hash from the buffer - targetStateCommitment = IBuffer(blockHashBuffer).parentChainBlockHash(targetBlockNumber); + targetStateCommitment = IBuffer(BLOCK_HASH_BUFFER).parentChainBlockHash(targetBlockNumber); } /// @notice Verify a storage slot given a target chain block hash and a proof. diff --git a/src/contracts/provers/linea/ParentToChildProver.sol b/src/contracts/provers/linea/ParentToChildProver.sol index 45f599e..f2b2cf2 100644 --- a/src/contracts/provers/linea/ParentToChildProver.sol +++ b/src/contracts/provers/linea/ParentToChildProver.sol @@ -18,14 +18,14 @@ import {ZkEvmV2} from "@linea-contracts/rollup/ZkEvmV2.sol"; /// The state root stored on L1 is the SMT root, which requires linea_getProof for verification. contract ParentToChildProver is IStateProver { /// @dev Address of the LineaRollup contract on L1 - address public immutable lineaRollup; + address public immutable LINEA_ROLLUP; /// @dev Storage slot of the stateRootHashes mapping in LineaRollup /// mapping(uint256 blockNumber => bytes32 stateRootHash) - uint256 public immutable stateRootHashesSlot; + uint256 public immutable STATE_ROOT_HASHES_SLOT; /// @dev L1 chain ID (home chain) - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); @@ -38,9 +38,9 @@ contract ParentToChildProver is IStateProver { error StorageKeyMismatch(); constructor(address _lineaRollup, uint256 _stateRootHashesSlot, uint256 _homeChainId) { - lineaRollup = _lineaRollup; - stateRootHashesSlot = _stateRootHashesSlot; - homeChainId = _homeChainId; + LINEA_ROLLUP = _lineaRollup; + STATE_ROOT_HASHES_SLOT = _stateRootHashesSlot; + HOME_CHAIN_ID = _homeChainId; } /// @notice Verify L2 state root using L1 LineaRollup storage proof @@ -54,7 +54,7 @@ contract ParentToChildProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } @@ -63,12 +63,12 @@ contract ParentToChildProver is IStateProver { abi.decode(input, (bytes, uint256, bytes, bytes)); // Calculate storage slot for stateRootHashes[l2BlockNumber] - uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(stateRootHashesSlot), l2BlockNumber)); + uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(STATE_ROOT_HASHES_SLOT), l2BlockNumber)); // Verify proofs and get the L2 state root from L1's LineaRollup // Note: L1 (Ethereum) uses MPT, so we use ProverUtils here targetStateCommitment = ProverUtils.getSlotFromBlockHeader( - homeStateCommitment, rlpBlockHeader, lineaRollup, slot, accountProof, storageProof + homeStateCommitment, rlpBlockHeader, LINEA_ROLLUP, slot, accountProof, storageProof ); if (targetStateCommitment == bytes32(0)) { @@ -81,7 +81,7 @@ contract ParentToChildProver is IStateProver { /// @param input ABI encoded (uint256 l2BlockNumber) /// @return targetStateCommitment The L2 state root function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } @@ -89,7 +89,7 @@ contract ParentToChildProver is IStateProver { uint256 l2BlockNumber = abi.decode(input, (uint256)); // Get the state root from LineaRollup - targetStateCommitment = ZkEvmV2(lineaRollup).stateRootHashes(l2BlockNumber); + targetStateCommitment = ZkEvmV2(LINEA_ROLLUP).stateRootHashes(l2BlockNumber); if (targetStateCommitment == bytes32(0)) { revert TargetStateRootNotFound(); diff --git a/src/contracts/provers/optimism/ChildToParentProver.sol b/src/contracts/provers/optimism/ChildToParentProver.sol index acef4fc..204023f 100644 --- a/src/contracts/provers/optimism/ChildToParentProver.sol +++ b/src/contracts/provers/optimism/ChildToParentProver.sol @@ -17,17 +17,17 @@ interface IL1Block { /// Pre-generated proofs become stale when L1Block updates (~5 minutes). /// Operational difference from Arbitrum: proofs must be generated just-in-time rather than pre-cached. contract ChildToParentProver is IStateProver { - address public constant l1BlockPredeploy = 0x4200000000000000000000000000000000000015; - uint256 public constant l1BlockHashSlot = 2; // hash is at slot 2 + address public constant L1_BLOCK_PREDEPLOY = 0x4200000000000000000000000000000000000015; + uint256 public constant L1_BLOCK_HASH_SLOT = 2; // hash is at slot 2 /// @dev The chain ID of the home chain (Optimism L2) - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); constructor(uint256 _homeChainId) { - homeChainId = _homeChainId; + HOME_CHAIN_ID = _homeChainId; } /// @notice Verify the latest available target block hash given a home chain block hash and a storage proof of the L1Block predeploy. @@ -38,7 +38,7 @@ contract ChildToParentProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } @@ -50,7 +50,7 @@ contract ChildToParentProver is IStateProver { // verify proofs and get the value targetStateCommitment = ProverUtils.getSlotFromBlockHeader( - homeBlockHash, rlpBlockHeader, l1BlockPredeploy, l1BlockHashSlot, accountProof, storageProof + homeBlockHash, rlpBlockHeader, L1_BLOCK_PREDEPLOY, L1_BLOCK_HASH_SLOT, accountProof, storageProof ); } @@ -64,10 +64,10 @@ contract ChildToParentProver is IStateProver { /// In this case, this prover contract may need to be modified to use a different source of block hashes, /// such as a backup contract that calls the L1Block predeploy and caches the latest block hash. function getTargetStateCommitment(bytes calldata) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } - return IL1Block(l1BlockPredeploy).hash(); + return IL1Block(L1_BLOCK_PREDEPLOY).hash(); } /// @notice Verify a storage slot given a target chain block hash and a proof. diff --git a/src/contracts/provers/optimism/ParentToChildProver.sol b/src/contracts/provers/optimism/ParentToChildProver.sol index 97c276d..a302976 100644 --- a/src/contracts/provers/optimism/ParentToChildProver.sol +++ b/src/contracts/provers/optimism/ParentToChildProver.sol @@ -33,17 +33,17 @@ contract ParentToChildProver is IStateProver { uint256 public constant ANCHOR_GAME_SLOT = 3; /// @notice The target chain's AnchorStateRegistry address. - address public immutable anchorStateRegistry; + address public immutable ANCHOR_STATE_REGISTRY; /// @dev The chain ID of the home chain (where this prover reads from). - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); constructor(address _anchorStateRegistry, uint256 _homeChainId) { - anchorStateRegistry = _anchorStateRegistry; - homeChainId = _homeChainId; + ANCHOR_STATE_REGISTRY = _anchorStateRegistry; + HOME_CHAIN_ID = _homeChainId; } /// @notice Verify the latest available target block hash given a home chain block hash, a storage proof of the AnchorStateRegistry, the anchor game proxy code and a root claim preimage. @@ -64,7 +64,7 @@ contract ParentToChildProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } @@ -87,7 +87,7 @@ contract ParentToChildProver is IStateProver { uint160( uint256( ProverUtils.getStorageSlotFromStateRoot( - stateRoot, asrAccountProof, asrStorageProof, anchorStateRegistry, ANCHOR_GAME_SLOT + stateRoot, asrAccountProof, asrStorageProof, ANCHOR_STATE_REGISTRY, ANCHOR_GAME_SLOT ) ) ) @@ -118,7 +118,7 @@ contract ParentToChildProver is IStateProver { /// 3. Return the latest block hash from the root claim preimage. /// @param input ABI encoded (address gameProxy, OutputRootProof rootClaimPreimage) function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } @@ -126,7 +126,7 @@ contract ParentToChildProver is IStateProver { (address gameProxy, OutputRootProof memory rootClaimPreimage) = abi.decode(input, (address, OutputRootProof)); // check the game proxy address - require(IAnchorStateRegistry(anchorStateRegistry).isGameClaimValid(gameProxy), "Invalid game proxy"); + require(IAnchorStateRegistry(ANCHOR_STATE_REGISTRY).isGameClaimValid(gameProxy), "Invalid game proxy"); bytes32 rootClaim = IFaultDisputeGame(gameProxy).rootClaim(); require(rootClaim == keccak256(abi.encode(rootClaimPreimage)), "Invalid root claim preimage"); diff --git a/src/contracts/provers/scroll/ChildToParentProver.sol b/src/contracts/provers/scroll/ChildToParentProver.sol index c24c401..ec5a4a3 100644 --- a/src/contracts/provers/scroll/ChildToParentProver.sol +++ b/src/contracts/provers/scroll/ChildToParentProver.sol @@ -12,23 +12,23 @@ import {SlotDerivation} from "@openzeppelin/contracts/utils/SlotDerivation.sol"; /// verifyStorageSlot is implemented to work against any parent chain with a standard Ethereum block header and state trie. contract ChildToParentProver is IStateProver { /// @dev Address of the block hash buffer contract. - address public immutable blockHashBuffer; + address public immutable BLOCK_HASH_BUFFER; /// @dev Storage slot the buffer contract uses to store block hashes. /// https://github.com/openintentsframework/broadcaster/blob/main/src/contracts/block-hash-pusher/BaseBuffer.sol - uint256 public constant blockHashMappingSlot = 1; + uint256 public constant BLOCK_HASH_MAPPING_SLOT = 1; /// @dev The chain ID of the home chain (child chain). - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); constructor(address _blockHashBuffer, uint256 _homeChainId) { - blockHashBuffer = _blockHashBuffer; - homeChainId = _homeChainId; + BLOCK_HASH_BUFFER = _blockHashBuffer; + HOME_CHAIN_ID = _homeChainId; } - /// @notice Get a parent chain block hash from the buffer at `blockHashBuffer` using a storage proof + /// @notice Get a parent chain block hash from the buffer at `BLOCK_HASH_BUFFER` using a storage proof /// @param homeBlockHash The block hash of the home chain. /// @param input ABI encoded (bytes blockHeader, uint256 targetBlockNumber, bytes accountProof, bytes storageProof) function verifyTargetStateCommitment(bytes32 homeBlockHash, bytes calldata input) @@ -36,7 +36,7 @@ contract ChildToParentProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } // decode the input @@ -45,25 +45,25 @@ contract ChildToParentProver is IStateProver { // calculate the slot based on the provided block number // see: https://github.com/OffchainLabs/block-hash-pusher/blob/a1e26f2e42e6306d1e7f03c5d20fa6aa64ff7a12/contracts/Buffer.sol#L32 - uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(blockHashMappingSlot), targetBlockNumber)); + uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(BLOCK_HASH_MAPPING_SLOT), targetBlockNumber)); // verify proofs and get the block hash targetStateCommitment = ProverUtils.getSlotFromBlockHeader( - homeBlockHash, rlpBlockHeader, blockHashBuffer, slot, accountProof, storageProof + homeBlockHash, rlpBlockHeader, BLOCK_HASH_BUFFER, slot, accountProof, storageProof ); } - /// @notice Get a parent chain block hash from the buffer at `blockHashBuffer`. + /// @notice Get a parent chain block hash from the buffer at `BLOCK_HASH_BUFFER`. /// @param input ABI encoded (uint256 targetBlockNumber) function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } // decode the input uint256 targetBlockNumber = abi.decode(input, (uint256)); // get the block hash from the buffer - targetStateCommitment = IBuffer(blockHashBuffer).parentChainBlockHash(targetBlockNumber); + targetStateCommitment = IBuffer(BLOCK_HASH_BUFFER).parentChainBlockHash(targetBlockNumber); } /// @notice Verify a storage slot given a target chain block hash and a proof. diff --git a/src/contracts/provers/scroll/ParentToChildProver.sol b/src/contracts/provers/scroll/ParentToChildProver.sol index c974ead..dc11574 100644 --- a/src/contracts/provers/scroll/ParentToChildProver.sol +++ b/src/contracts/provers/scroll/ParentToChildProver.sol @@ -18,15 +18,15 @@ import {IScrollChain} from "@scroll-tech/scroll-contracts/L1/rollup/IScrollChain /// the L2 block header. contract ParentToChildProver is IStateProver { /// @dev Address of the ScrollChain contract on L1 - address public immutable scrollChain; + address public immutable SCROLL_CHAIN; /// @dev Storage slot where ScrollChain stores the finalizedStateRoots mapping /// mapping(uint256 batchIndex => bytes32 stateRoot) /// This is slot 7 in the ScrollChain contract (after upgradeable storage gaps) - uint256 public immutable finalizedStateRootsSlot; + uint256 public immutable FINALIZED_STATE_ROOTS_SLOT; /// @dev L1 chain ID (home chain where this prover reads from) - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); @@ -37,9 +37,9 @@ contract ParentToChildProver is IStateProver { /// @param _finalizedStateRootsSlot Storage slot of the finalizedStateRoots mapping /// @param _homeChainId Chain ID of the home chain (L1) constructor(address _scrollChain, uint256 _finalizedStateRootsSlot, uint256 _homeChainId) { - scrollChain = _scrollChain; - finalizedStateRootsSlot = _finalizedStateRootsSlot; - homeChainId = _homeChainId; + SCROLL_CHAIN = _scrollChain; + FINALIZED_STATE_ROOTS_SLOT = _finalizedStateRootsSlot; + HOME_CHAIN_ID = _homeChainId; } /// @notice Verify L2 state root using L1 ScrollChain storage proof @@ -52,7 +52,7 @@ contract ParentToChildProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } @@ -61,12 +61,12 @@ contract ParentToChildProver is IStateProver { abi.decode(input, (bytes, uint256, bytes, bytes)); // Calculate the storage slot for the finalized state root - // slot = keccak256(abi.encode(batchIndex, finalizedStateRootsSlot)) - uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(finalizedStateRootsSlot), batchIndex)); + // slot = keccak256(abi.encode(batchIndex, FINALIZED_STATE_ROOTS_SLOT)) + uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(FINALIZED_STATE_ROOTS_SLOT), batchIndex)); // Verify proofs and get the L2 state root from L1's ScrollChain targetStateCommitment = ProverUtils.getSlotFromBlockHeader( - homeBlockHash, rlpBlockHeader, scrollChain, slot, accountProof, storageProof + homeBlockHash, rlpBlockHeader, SCROLL_CHAIN, slot, accountProof, storageProof ); if (targetStateCommitment == bytes32(0)) { @@ -79,7 +79,7 @@ contract ParentToChildProver is IStateProver { /// @param input ABI encoded (uint256 batchIndex) /// @return targetStateCommitment The L2 state root (NOTE: this is a state root, not a block hash) function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } @@ -87,7 +87,7 @@ contract ParentToChildProver is IStateProver { uint256 batchIndex = abi.decode(input, (uint256)); // Get the state root from ScrollChain - targetStateCommitment = IScrollChain(scrollChain).finalizedStateRoots(batchIndex); + targetStateCommitment = IScrollChain(SCROLL_CHAIN).finalizedStateRoots(batchIndex); if (targetStateCommitment == bytes32(0)) { revert StateRootNotFound(); diff --git a/src/contracts/provers/taiko/ChildToParentProver.sol b/src/contracts/provers/taiko/ChildToParentProver.sol index b3ab4d8..5d0752d 100644 --- a/src/contracts/provers/taiko/ChildToParentProver.sol +++ b/src/contracts/provers/taiko/ChildToParentProver.sol @@ -22,24 +22,24 @@ interface ICheckpointStore { /// verifyStorageSlot works against any Ethereum-compatible chain with standard block headers. contract ChildToParentProver is IStateProver { /// @dev Address of the L2 SignalService contract - address public immutable signalService; + address public immutable SIGNAL_SERVICE; /// @dev Storage slot where SignalService stores checkpoints mapping /// mapping(uint48 blockNumber => CheckpointRecord checkpoint) /// CheckpointRecord { bytes32 blockHash; bytes32 stateRoot; } - uint256 public immutable checkpointsSlot; + uint256 public immutable CHECKPOINTS_SLOT; /// @dev L2 chain ID (home chain where this prover is deployed) - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); error TargetBlockHashNotFound(); constructor(address _signalService, uint256 _checkpointsSlot, uint256 _homeChainId) { - signalService = _signalService; - checkpointsSlot = _checkpointsSlot; - homeChainId = _homeChainId; + SIGNAL_SERVICE = _signalService; + CHECKPOINTS_SLOT = _checkpointsSlot; + HOME_CHAIN_ID = _homeChainId; } /// @notice Verify L1 block hash using L2 SignalService checkpoint with storage proof @@ -52,7 +52,7 @@ contract ChildToParentProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } @@ -61,13 +61,13 @@ contract ChildToParentProver is IStateProver { abi.decode(input, (bytes, uint48, bytes, bytes)); // Calculate the storage slot for the checkpoint - // checkpointSlot = keccak256(abi.encode(l1BlockNumber, checkpointsSlot)) - uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(checkpointsSlot), l1BlockNumber)); + // checkpointSlot = keccak256(abi.encode(l1BlockNumber, CHECKPOINTS_SLOT)) + uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(CHECKPOINTS_SLOT), l1BlockNumber)); // Verify proofs and get the L1 block hash from L2's SignalService // CheckpointRecord.blockHash is stored at the base slot targetStateCommitment = ProverUtils.getSlotFromBlockHeader( - homeBlockHash, rlpBlockHeader, signalService, slot, accountProof, storageProof + homeBlockHash, rlpBlockHeader, SIGNAL_SERVICE, slot, accountProof, storageProof ); if (targetStateCommitment == bytes32(0)) { @@ -80,7 +80,7 @@ contract ChildToParentProver is IStateProver { /// @param input ABI encoded (uint48 l1BlockNumber) /// @return targetStateCommitment The L1 block hash function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } @@ -88,7 +88,7 @@ contract ChildToParentProver is IStateProver { uint48 l1BlockNumber = abi.decode(input, (uint48)); // Get the checkpoint from SignalService - ICheckpointStore.Checkpoint memory checkpoint = ICheckpointStore(signalService).getCheckpoint(l1BlockNumber); + ICheckpointStore.Checkpoint memory checkpoint = ICheckpointStore(SIGNAL_SERVICE).getCheckpoint(l1BlockNumber); targetStateCommitment = checkpoint.blockHash; diff --git a/src/contracts/provers/taiko/ParentToChildProver.sol b/src/contracts/provers/taiko/ParentToChildProver.sol index 228b3e5..a648cd3 100644 --- a/src/contracts/provers/taiko/ParentToChildProver.sol +++ b/src/contracts/provers/taiko/ParentToChildProver.sol @@ -22,24 +22,24 @@ interface ICheckpointStore { /// verifyStorageSlot works against any Ethereum-compatible chain with standard block headers. contract ParentToChildProver is IStateProver { /// @dev Address of the L1 SignalService contract - address public immutable signalService; + address public immutable SIGNAL_SERVICE; /// @dev Storage slot where SignalService stores checkpoints mapping /// mapping(uint48 blockNumber => CheckpointRecord checkpoint) /// CheckpointRecord { bytes32 blockHash; bytes32 stateRoot; } - uint256 public immutable checkpointsSlot; + uint256 public immutable CHECKPOINTS_SLOT; /// @dev L1 chain ID (home chain where this prover is deployed) - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); error TargetBlockHashNotFound(); constructor(address _signalService, uint256 _checkpointsSlot, uint256 _homeChainId) { - signalService = _signalService; - checkpointsSlot = _checkpointsSlot; - homeChainId = _homeChainId; + SIGNAL_SERVICE = _signalService; + CHECKPOINTS_SLOT = _checkpointsSlot; + HOME_CHAIN_ID = _homeChainId; } /// @notice Verify L2 block hash using L1 SignalService checkpoint with storage proof @@ -52,7 +52,7 @@ contract ParentToChildProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } @@ -61,13 +61,13 @@ contract ParentToChildProver is IStateProver { abi.decode(input, (bytes, uint48, bytes, bytes)); // Calculate the storage slot for the checkpoint - // checkpointSlot = keccak256(abi.encode(l2BlockNumber, checkpointsSlot)) - uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(checkpointsSlot), l2BlockNumber)); + // checkpointSlot = keccak256(abi.encode(l2BlockNumber, CHECKPOINTS_SLOT)) + uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(CHECKPOINTS_SLOT), l2BlockNumber)); // Verify proofs and get the L2 block hash from L1's SignalService // CheckpointRecord.blockHash is stored at the base slot targetStateCommitment = ProverUtils.getSlotFromBlockHeader( - homeBlockHash, rlpBlockHeader, signalService, slot, accountProof, storageProof + homeBlockHash, rlpBlockHeader, SIGNAL_SERVICE, slot, accountProof, storageProof ); if (targetStateCommitment == bytes32(0)) { @@ -80,7 +80,7 @@ contract ParentToChildProver is IStateProver { /// @param input ABI encoded (uint48 l2BlockNumber) /// @return targetStateCommitment The L2 block hash function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } @@ -88,7 +88,7 @@ contract ParentToChildProver is IStateProver { uint48 l2BlockNumber = abi.decode(input, (uint48)); // Get the checkpoint from SignalService - ICheckpointStore.Checkpoint memory checkpoint = ICheckpointStore(signalService).getCheckpoint(l2BlockNumber); + ICheckpointStore.Checkpoint memory checkpoint = ICheckpointStore(SIGNAL_SERVICE).getCheckpoint(l2BlockNumber); targetStateCommitment = checkpoint.blockHash; diff --git a/src/contracts/provers/zksync/ChildToParentProver.sol b/src/contracts/provers/zksync/ChildToParentProver.sol index 20a950c..9027166 100644 --- a/src/contracts/provers/zksync/ChildToParentProver.sol +++ b/src/contracts/provers/zksync/ChildToParentProver.sol @@ -12,23 +12,23 @@ import {SlotDerivation} from "@openzeppelin/contracts/utils/SlotDerivation.sol"; /// verifyStorageSlot is implemented to work against any parent chain with a standard Ethereum block header and state trie. contract ChildToParentProver is IStateProver { /// @dev Address of the block hash buffer contract. - address public immutable blockHashBuffer; + address public immutable BLOCK_HASH_BUFFER; /// @dev Storage slot the buffer contract uses to store block hashes. /// See https://github.com/openintentsframework/broadcaster/blob/main/src/contracts/block-hash-pusher/BaseBuffer.sol - uint256 public constant blockHashMappingSlot = 1; + uint256 public constant BLOCK_HASH_MAPPING_SLOT = 1; /// @dev The chain ID of the home chain (child chain). - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; error CallNotOnHomeChain(); error CallOnHomeChain(); constructor(address _blockHashBuffer, uint256 _homeChainId) { - blockHashBuffer = _blockHashBuffer; - homeChainId = _homeChainId; + BLOCK_HASH_BUFFER = _blockHashBuffer; + HOME_CHAIN_ID = _homeChainId; } - /// @notice Get a parent chain block hash from the buffer at `blockHashBuffer` using a storage proof + /// @notice Get a parent chain block hash from the buffer at `BLOCK_HASH_BUFFER` using a storage proof /// @param homeBlockHash The block hash of the home chain. /// @param input ABI encoded (bytes blockHeader, uint256 targetBlockNumber, bytes accountProof, bytes storageProof) function verifyTargetStateCommitment(bytes32 homeBlockHash, bytes calldata input) @@ -36,7 +36,7 @@ contract ChildToParentProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } // decode the input @@ -45,25 +45,25 @@ contract ChildToParentProver is IStateProver { // calculate the slot based on the provided block number // see: https://github.com/OffchainLabs/block-hash-pusher/blob/a1e26f2e42e6306d1e7f03c5d20fa6aa64ff7a12/contracts/Buffer.sol#L32 - uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(blockHashMappingSlot), targetBlockNumber)); + uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(BLOCK_HASH_MAPPING_SLOT), targetBlockNumber)); // verify proofs and get the block hash targetStateCommitment = ProverUtils.getSlotFromBlockHeader( - homeBlockHash, rlpBlockHeader, blockHashBuffer, slot, accountProof, storageProof + homeBlockHash, rlpBlockHeader, BLOCK_HASH_BUFFER, slot, accountProof, storageProof ); } - /// @notice Get a parent chain block hash from the buffer at `blockHashBuffer`. + /// @notice Get a parent chain block hash from the buffer at `BLOCK_HASH_BUFFER`. /// @param input ABI encoded (uint256 targetBlockNumber) function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } // decode the input uint256 targetBlockNumber = abi.decode(input, (uint256)); // get the block hash from the buffer - targetStateCommitment = IBuffer(blockHashBuffer).parentChainBlockHash(targetBlockNumber); + targetStateCommitment = IBuffer(BLOCK_HASH_BUFFER).parentChainBlockHash(targetBlockNumber); } /// @notice Verify a storage slot given a target chain block hash and a proof. diff --git a/src/contracts/provers/zksync/ParentToChildProver.sol b/src/contracts/provers/zksync/ParentToChildProver.sol index da08949..7ce5135 100644 --- a/src/contracts/provers/zksync/ParentToChildProver.sol +++ b/src/contracts/provers/zksync/ParentToChildProver.sol @@ -62,19 +62,19 @@ struct ZkSyncProof { /// use the gateway as a middleware between the L2 and the L1. contract ParentToChildProver is IStateProver { /// @notice The ZkChain contract address on the gateway chain that stores L2 logs root hashes. - IZkChain public immutable gatewayZkChain; + IZkChain public immutable GATEWAY_ZK_CHAIN; /// @notice The storage slot base for the L2 logs root hash mapping in the gateway ZkChain contract. - uint256 public immutable l2LogsRootHashSlot; + uint256 public immutable L2_LOGS_ROOT_HASH_SLOT; /// @notice The chain ID of the child chain (L2) for which this prover verifies messages. - uint256 public immutable childChainId; + uint256 public immutable CHILD_CHAIN_ID; /// @notice The chain ID of the gateway chain (settlement layer) that bridges between parent and child chains. - uint256 public immutable gatewayChainId; + uint256 public immutable GATEWAY_CHAIN_ID; /// @notice The chain ID of the home chain (L1) where this prover is deployed. - uint256 public immutable homeChainId; + uint256 public immutable HOME_CHAIN_ID; /// @notice Error thrown when the requested L2 logs root hash is not found (returns zero). error L2LogsRootHashNotFound(); @@ -101,11 +101,11 @@ contract ParentToChildProver is IStateProver { uint256 _gatewayChainId, uint256 _homeChainId ) { - gatewayZkChain = IZkChain(_gatewayZkChain); - l2LogsRootHashSlot = _l2LogsRootHashSlot; - childChainId = _childChainId; - gatewayChainId = _gatewayChainId; - homeChainId = _homeChainId; + GATEWAY_ZK_CHAIN = IZkChain(_gatewayZkChain); + L2_LOGS_ROOT_HASH_SLOT = _l2LogsRootHashSlot; + CHILD_CHAIN_ID = _childChainId; + GATEWAY_CHAIN_ID = _gatewayChainId; + HOME_CHAIN_ID = _homeChainId; } /// @notice Verify a target chain L2 logs root hash given a home chain block hash and a proof. @@ -122,18 +122,18 @@ contract ParentToChildProver is IStateProver { view returns (bytes32 targetStateCommitment) { - if (block.chainid == homeChainId) { + if (block.chainid == HOME_CHAIN_ID) { revert CallOnHomeChain(); } // decode the input (bytes memory rlpBlockHeader, uint256 batchNumber, bytes memory accountProof, bytes memory storageProof) = abi.decode(input, (bytes, uint256, bytes, bytes)); - uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(l2LogsRootHashSlot), batchNumber)); + uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(L2_LOGS_ROOT_HASH_SLOT), batchNumber)); // verify proofs and get the L2 logs root hash targetStateCommitment = ProverUtils.getSlotFromBlockHeader( - homeStateCommitment, rlpBlockHeader, address(gatewayZkChain), slot, accountProof, storageProof + homeStateCommitment, rlpBlockHeader, address(GATEWAY_ZK_CHAIN), slot, accountProof, storageProof ); } @@ -144,12 +144,12 @@ contract ParentToChildProver is IStateProver { /// @return targetStateCommitment The L2 logs root hash for the specified batch number. /// @custom:reverts L2LogsRootHashNotFound if the L2 logs root hash is not found (returns zero). function getTargetStateCommitment(bytes calldata input) external view returns (bytes32 targetStateCommitment) { - if (block.chainid != homeChainId) { + if (block.chainid != HOME_CHAIN_ID) { revert CallNotOnHomeChain(); } uint256 batchNumber = abi.decode(input, (uint256)); - targetStateCommitment = gatewayZkChain.l2LogsRootHash(batchNumber); + targetStateCommitment = GATEWAY_ZK_CHAIN.l2LogsRootHash(batchNumber); if (targetStateCommitment == bytes32(0)) { revert L2LogsRootHashNotFound(); @@ -188,7 +188,7 @@ contract ParentToChildProver is IStateProver { ); if (!_proveL2LeafInclusion({ - _chainId: childChainId, + _chainId: CHILD_CHAIN_ID, _blockOrBatchNumber: proof.batchNumber, _leafProofMask: proof.index, _leaf: hashedLog, @@ -242,7 +242,7 @@ contract ParentToChildProver is IStateProver { return _targetBatchRoot == proofData.batchSettlementRoot && _targetBatchRoot != bytes32(0); } - if (proofData.settlementLayerChainId != gatewayChainId) { + if (proofData.settlementLayerChainId != GATEWAY_CHAIN_ID) { revert ChainIdMismatch(); } diff --git a/test/Receiver.t.sol b/test/Receiver.t.sol index 2def15b..e71aae0 100644 --- a/test/Receiver.t.sol +++ b/test/Receiver.t.sol @@ -282,7 +282,7 @@ contract ReceiverTest is Test { assertEq(blockHash, expectedBlockHash); bytes memory input = abi.encode(rlpBlockHeader, account, slot, rlpAccountProof, rlpStorageProof); - IL1Block l1Block = IL1Block(childToParentProver.l1BlockPredeploy()); + IL1Block l1Block = IL1Block(childToParentProver.L1_BLOCK_PREDEPLOY()); vm.prank(l1Block.DEPOSITOR_ACCOUNT()); l1Block.setL1BlockValues( @@ -353,7 +353,7 @@ contract ReceiverTest is Test { assertEq(blockHash, expectedBlockHash); bytes memory input = abi.encode(rlpBlockHeader, account, slot, rlpAccountProof, rlpStorageProof); - IL1Block l1Block = IL1Block(childToParentProver.l1BlockPredeploy()); + IL1Block l1Block = IL1Block(childToParentProver.L1_BLOCK_PREDEPLOY()); vm.prank(l1Block.DEPOSITOR_ACCOUNT()); l1Block.setL1BlockValues( @@ -426,7 +426,7 @@ contract ReceiverTest is Test { assertEq(blockHash, expectedBlockHash); bytes memory input = abi.encode(rlpBlockHeader, account, slot, rlpAccountProof, rlpStorageProof); - IL1Block l1Block = IL1Block(childToParentProver.l1BlockPredeploy()); + IL1Block l1Block = IL1Block(childToParentProver.L1_BLOCK_PREDEPLOY()); vm.prank(l1Block.DEPOSITOR_ACCOUNT()); l1Block.setL1BlockValues( @@ -491,7 +491,7 @@ contract ReceiverTest is Test { bytes memory inputForOPChildToParentProver = abi.encode(rlpBlockHeader, account, slot, rlpAccountProof, rlpStorageProof); - IL1Block l1Block = IL1Block(childToParentProver.l1BlockPredeploy()); + IL1Block l1Block = IL1Block(childToParentProver.L1_BLOCK_PREDEPLOY()); vm.prank(l1Block.DEPOSITOR_ACCOUNT()); l1Block.setL1BlockValues( @@ -555,7 +555,7 @@ contract ReceiverTest is Test { bytes memory rlpAccountProofArbitrum = jsonArbitrum.readBytes(".rlpAccountProof"); bytes memory rlpStorageProofArbitrum = jsonArbitrum.readBytes(".rlpStorageProof"); - IL1Block l1Block = IL1Block(childToParentProver.l1BlockPredeploy()); + IL1Block l1Block = IL1Block(childToParentProver.L1_BLOCK_PREDEPLOY()); vm.prank(l1Block.DEPOSITOR_ACCOUNT()); l1Block.setL1BlockValues( diff --git a/test/VerifyBroadcastMessageBenchmark.t.sol b/test/VerifyBroadcastMessageBenchmark.t.sol index 01ad5a1..2f7c0c0 100644 --- a/test/VerifyBroadcastMessageBenchmark.t.sol +++ b/test/VerifyBroadcastMessageBenchmark.t.sol @@ -369,7 +369,7 @@ contract VerifyBroadcastMessageBenchmark is Test { address publisher = 0x9a56fFd72F4B526c523C733F1F74197A51c495E1; // Mock L1Block predeploy - address l1Block = prover.l1BlockPredeploy(); + address l1Block = prover.L1_BLOCK_PREDEPLOY(); vm.mockCall(l1Block, abi.encodeWithSignature("hash()"), abi.encode(blockHash)); vm.mockCall(l1Block, abi.encodeWithSignature("number()"), abi.encode(blockNumber)); @@ -435,7 +435,7 @@ contract VerifyBroadcastMessageBenchmark is Test { bytes32 ethBlockHash = ethJson.readBytes32(".blockHash"); // Mock L1Block predeploy for first hop - address l1Block = opC2PProver.l1BlockPredeploy(); + address l1Block = opC2PProver.L1_BLOCK_PREDEPLOY(); vm.mockCall(l1Block, abi.encodeWithSignature("hash()"), abi.encode(ethBlockHash)); vm.mockCall(l1Block, abi.encodeWithSignature("number()"), abi.encode(ethBlockNumber)); diff --git a/test/provers/linea/ParentToChildProver.t.sol b/test/provers/linea/ParentToChildProver.t.sol index af86bee..a3cfa32 100644 --- a/test/provers/linea/ParentToChildProver.t.sol +++ b/test/provers/linea/ParentToChildProver.t.sol @@ -68,23 +68,23 @@ contract LineaParentToChildProverTest is Test { // ═══════════════════════════════════════════════════════════════════════════ function test_constructor() public view { - assertEq(prover.lineaRollup(), address(mockLineaRollup)); - assertEq(prover.stateRootHashesSlot(), STATE_ROOT_HASHES_SLOT); - assertEq(prover.homeChainId(), ETH_MAINNET_CHAIN_ID); + assertEq(prover.LINEA_ROLLUP(), address(mockLineaRollup)); + assertEq(prover.STATE_ROOT_HASHES_SLOT(), STATE_ROOT_HASHES_SLOT); + assertEq(prover.HOME_CHAIN_ID(), ETH_MAINNET_CHAIN_ID); } function test_constructor_differentParameters() public { ParentToChildProver newProver = new ParentToChildProver(address(0x123), 99, 12345); - assertEq(newProver.lineaRollup(), address(0x123)); - assertEq(newProver.stateRootHashesSlot(), 99); - assertEq(newProver.homeChainId(), 12345); + assertEq(newProver.LINEA_ROLLUP(), address(0x123)); + assertEq(newProver.STATE_ROOT_HASHES_SLOT(), 99); + assertEq(newProver.HOME_CHAIN_ID(), 12345); } function testFuzz_constructor_acceptsAnyParameters(address _lineaRollup, uint256 _slot, uint256 _chainId) public { ParentToChildProver newProver = new ParentToChildProver(_lineaRollup, _slot, _chainId); - assertEq(newProver.lineaRollup(), _lineaRollup); - assertEq(newProver.stateRootHashesSlot(), _slot); - assertEq(newProver.homeChainId(), _chainId); + assertEq(newProver.LINEA_ROLLUP(), _lineaRollup); + assertEq(newProver.STATE_ROOT_HASHES_SLOT(), _slot); + assertEq(newProver.HOME_CHAIN_ID(), _chainId); } // ═══════════════════════════════════════════════════════════════════════════ diff --git a/test/provers/scroll/ParentToChildProver.t.sol b/test/provers/scroll/ParentToChildProver.t.sol index 17ee513..d46479a 100644 --- a/test/provers/scroll/ParentToChildProver.t.sol +++ b/test/provers/scroll/ParentToChildProver.t.sol @@ -255,8 +255,8 @@ contract ScrollChainMock is IScrollChain { /// @notice Test constructor sets immutables correctly function test_constructor() public view { - assertEq(parentToChildProver.scrollChain(), address(scrollChainMock)); - assertEq(parentToChildProver.finalizedStateRootsSlot(), FINALIZED_STATE_ROOTS_SLOT); - assertEq(parentToChildProver.homeChainId(), l1ChainId); + assertEq(parentToChildProver.SCROLL_CHAIN(), address(scrollChainMock)); + assertEq(parentToChildProver.FINALIZED_STATE_ROOTS_SLOT(), FINALIZED_STATE_ROOTS_SLOT); + assertEq(parentToChildProver.HOME_CHAIN_ID(), l1ChainId); } } diff --git a/test/provers/taiko/ChildToParentProver.t.sol b/test/provers/taiko/ChildToParentProver.t.sol index 06629c1..1bcb070 100644 --- a/test/provers/taiko/ChildToParentProver.t.sol +++ b/test/provers/taiko/ChildToParentProver.t.sol @@ -67,9 +67,9 @@ contract TaikoChildToParentProverTest is Test { // ═══════════════════════════════════════════════════════════════════════════ function test_constructor() public view { - assertEq(prover.signalService(), address(mockSignalService), "signalService mismatch"); - assertEq(prover.checkpointsSlot(), CHECKPOINTS_SLOT, "checkpointsSlot mismatch"); - assertEq(prover.homeChainId(), L2_CHAIN_ID, "homeChainId mismatch"); + assertEq(prover.SIGNAL_SERVICE(), address(mockSignalService), "SIGNAL_SERVICE mismatch"); + assertEq(prover.CHECKPOINTS_SLOT(), CHECKPOINTS_SLOT, "CHECKPOINTS_SLOT mismatch"); + assertEq(prover.HOME_CHAIN_ID(), L2_CHAIN_ID, "HOME_CHAIN_ID mismatch"); } function test_version() public view { @@ -268,8 +268,8 @@ contract TaikoChildToParentProverTest is Test { ChildToParentProver customProver = new ChildToParentProver(customSignalService, customSlot, customChainId); - assertEq(customProver.signalService(), customSignalService); - assertEq(customProver.checkpointsSlot(), customSlot); - assertEq(customProver.homeChainId(), customChainId); + assertEq(customProver.SIGNAL_SERVICE(), customSignalService); + assertEq(customProver.CHECKPOINTS_SLOT(), customSlot); + assertEq(customProver.HOME_CHAIN_ID(), customChainId); } } diff --git a/test/provers/taiko/ParentToChildProver.t.sol b/test/provers/taiko/ParentToChildProver.t.sol index a18e8f8..cd05866 100644 --- a/test/provers/taiko/ParentToChildProver.t.sol +++ b/test/provers/taiko/ParentToChildProver.t.sol @@ -67,9 +67,9 @@ contract TaikoParentToChildProverTest is Test { // ═══════════════════════════════════════════════════════════════════════════ function test_constructor() public view { - assertEq(prover.signalService(), address(mockSignalService), "signalService mismatch"); - assertEq(prover.checkpointsSlot(), CHECKPOINTS_SLOT, "checkpointsSlot mismatch"); - assertEq(prover.homeChainId(), L1_CHAIN_ID, "homeChainId mismatch"); + assertEq(prover.SIGNAL_SERVICE(), address(mockSignalService), "SIGNAL_SERVICE mismatch"); + assertEq(prover.CHECKPOINTS_SLOT(), CHECKPOINTS_SLOT, "CHECKPOINTS_SLOT mismatch"); + assertEq(prover.HOME_CHAIN_ID(), L1_CHAIN_ID, "HOME_CHAIN_ID mismatch"); } function test_version() public view { @@ -268,9 +268,9 @@ contract TaikoParentToChildProverTest is Test { ParentToChildProver customProver = new ParentToChildProver(customSignalService, customSlot, customChainId); - assertEq(customProver.signalService(), customSignalService); - assertEq(customProver.checkpointsSlot(), customSlot); - assertEq(customProver.homeChainId(), customChainId); + assertEq(customProver.SIGNAL_SERVICE(), customSignalService); + assertEq(customProver.CHECKPOINTS_SLOT(), customSlot); + assertEq(customProver.HOME_CHAIN_ID(), customChainId); } // ═══════════════════════════════════════════════════════════════════════════ @@ -293,8 +293,8 @@ contract TaikoParentToChildProverTest is Test { ParentToChildProver fuzzProver = new ParentToChildProver(signalService, slot, chainId); - assertEq(fuzzProver.signalService(), signalService); - assertEq(fuzzProver.checkpointsSlot(), slot); - assertEq(fuzzProver.homeChainId(), chainId); + assertEq(fuzzProver.SIGNAL_SERVICE(), signalService); + assertEq(fuzzProver.CHECKPOINTS_SLOT(), slot); + assertEq(fuzzProver.HOME_CHAIN_ID(), chainId); } }