diff --git a/packages/contracts-bedrock/interfaces/dispute/IAnchorStateRegistry.sol b/packages/contracts-bedrock/interfaces/dispute/IAnchorStateRegistry.sol index d6c96648e63..14a745f5dcf 100644 --- a/packages/contracts-bedrock/interfaces/dispute/IAnchorStateRegistry.sol +++ b/packages/contracts-bedrock/interfaces/dispute/IAnchorStateRegistry.sol @@ -5,7 +5,7 @@ import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; import { IFaultDisputeGame } from "interfaces/dispute/IFaultDisputeGame.sol"; import { IDisputeGameFactory } from "interfaces/dispute/IDisputeGameFactory.sol"; import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; -import { GameType, Hash, OutputRoot } from "src/dispute/lib/Types.sol"; +import { GameType, Hash, Proposal } from "src/dispute/lib/Types.sol"; interface IAnchorStateRegistry { error AnchorStateRegistry_AnchorGameBlacklisted(); @@ -28,7 +28,7 @@ interface IAnchorStateRegistry { function initialize( ISuperchainConfig _superchainConfig, IDisputeGameFactory _disputeGameFactory, - OutputRoot memory _startingAnchorRoot, + Proposal memory _startingAnchorRoot, GameType _startingRespectedGameType ) external; diff --git a/packages/contracts-bedrock/interfaces/dispute/IDisputeGame.sol b/packages/contracts-bedrock/interfaces/dispute/IDisputeGame.sol index 37653759875..85bb61606de 100644 --- a/packages/contracts-bedrock/interfaces/dispute/IDisputeGame.sol +++ b/packages/contracts-bedrock/interfaces/dispute/IDisputeGame.sol @@ -14,7 +14,7 @@ interface IDisputeGame is IInitializable { function gameCreator() external pure returns (address creator_); function rootClaim() external pure returns (Claim rootClaim_); function l1Head() external pure returns (Hash l1Head_); - function l2BlockNumber() external pure returns (uint256 l2BlockNumber_); + function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); function extraData() external pure returns (bytes memory extraData_); function resolve() external returns (GameStatus status_); function gameData() external view returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); diff --git a/packages/contracts-bedrock/interfaces/dispute/IFaultDisputeGame.sol b/packages/contracts-bedrock/interfaces/dispute/IFaultDisputeGame.sol index 8cf4996019c..9beccc00a53 100644 --- a/packages/contracts-bedrock/interfaces/dispute/IFaultDisputeGame.sol +++ b/packages/contracts-bedrock/interfaces/dispute/IFaultDisputeGame.sol @@ -128,7 +128,7 @@ interface IFaultDisputeGame is IDisputeGame { function resolvedSubgames(uint256) external view returns (bool); function splitDepth() external view returns (uint256 splitDepth_); function startingBlockNumber() external view returns (uint256 startingBlockNumber_); - function startingOutputRoot() external view returns (Hash root, uint256 l2BlockNumber); // nosemgrep + function startingOutputRoot() external view returns (Hash root, uint256 l2SequenceNumber); // nosemgrep function startingRootHash() external view returns (Hash startingRootHash_); function step(uint256 _claimIndex, bool _isAttack, bytes memory _stateData, bytes memory _proof) external; function subgames(uint256, uint256) external view returns (uint256); diff --git a/packages/contracts-bedrock/interfaces/dispute/IPermissionedDisputeGame.sol b/packages/contracts-bedrock/interfaces/dispute/IPermissionedDisputeGame.sol index ca235c34532..902f4dfec5c 100644 --- a/packages/contracts-bedrock/interfaces/dispute/IPermissionedDisputeGame.sol +++ b/packages/contracts-bedrock/interfaces/dispute/IPermissionedDisputeGame.sol @@ -118,7 +118,7 @@ interface IPermissionedDisputeGame is IDisputeGame { function resolvedSubgames(uint256) external view returns (bool); function splitDepth() external view returns (uint256 splitDepth_); function startingBlockNumber() external view returns (uint256 startingBlockNumber_); - function startingOutputRoot() external view returns (Hash root, uint256 l2BlockNumber); // nosemgrep + function startingOutputRoot() external view returns (Hash root, uint256 l2SequenceNumber); // nosemgrep function startingRootHash() external view returns (Hash startingRootHash_); function step(uint256 _claimIndex, bool _isAttack, bytes memory _stateData, bytes memory _proof) external; function subgames(uint256, uint256) external view returns (uint256); diff --git a/packages/contracts-bedrock/interfaces/dispute/ISuperFaultDisputeGame.sol b/packages/contracts-bedrock/interfaces/dispute/ISuperFaultDisputeGame.sol new file mode 100644 index 00000000000..c379b842518 --- /dev/null +++ b/packages/contracts-bedrock/interfaces/dispute/ISuperFaultDisputeGame.sol @@ -0,0 +1,128 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; +import { IDelayedWETH } from "interfaces/dispute/IDelayedWETH.sol"; +import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol"; +import { IBigStepper } from "interfaces/dispute/IBigStepper.sol"; +import { GameType, Claim, Position, Clock, Hash, Duration, BondDistributionMode } from "src/dispute/lib/Types.sol"; + +interface ISuperFaultDisputeGame is IDisputeGame { + struct ClaimData { + uint32 parentIndex; + address counteredBy; + address claimant; + uint128 bond; + Claim claim; + Position position; + Clock clock; + } + + struct ResolutionCheckpoint { + bool initialCheckpointComplete; + uint32 subgameIndex; + Position leftmostPosition; + address counteredBy; + } + + struct GameConstructorParams { + GameType gameType; + Claim absolutePrestate; + uint256 maxGameDepth; + uint256 splitDepth; + Duration clockExtension; + Duration maxClockDuration; + IBigStepper vm; + IDelayedWETH weth; + IAnchorStateRegistry anchorStateRegistry; + uint256 l2ChainId; + } + + error AlreadyInitialized(); + error AnchorRootNotFound(); + error BondTransferFailed(); + error CannotDefendRootClaim(); + error ClaimAboveSplit(); + error ClaimAlreadyExists(); + error ClaimAlreadyResolved(); + error ClockNotExpired(); + error ClockTimeExceeded(); + error DuplicateStep(); + error GameDepthExceeded(); + error GameNotInProgress(); + error IncorrectBondAmount(); + error InvalidChallengePeriod(); + error InvalidClockExtension(); + error InvalidDisputedClaimIndex(); + error InvalidLocalIdent(); + error InvalidParent(); + error InvalidPrestate(); + error InvalidSplitDepth(); + error MaxDepthTooLarge(); + error NoCreditToClaim(); + error NoChainIdNeeded(); + error OutOfOrderResolution(); + error SuperFaultDisputeGameInvalidRootClaim(); + error UnexpectedRootClaim(Claim rootClaim); + error ValidStep(); + error InvalidBondDistributionMode(); + error GameNotFinalized(); + error GameNotResolved(); + error ReservedGameType(); + + event Move(uint256 indexed parentIndex, Claim indexed claim, address indexed claimant); + event GameClosed(BondDistributionMode bondDistributionMode); + + function absolutePrestate() external view returns (Claim absolutePrestate_); + function addLocalData(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset) external; + function anchorStateRegistry() external view returns (IAnchorStateRegistry registry_); + function attack(Claim _disputed, uint256 _parentIndex, Claim _claim) external payable; + function bondDistributionMode() external view returns (BondDistributionMode); + function claimCredit(address _recipient) external; + function claimData(uint256) + external + view // nosemgrep + returns ( + uint32 parentIndex, + address counteredBy, + address claimant, + uint128 bond, + Claim claim, + Position position, + Clock clock + ); + function claimDataLen() external view returns (uint256 len_); + function claims(Hash) external view returns (bool); + function clockExtension() external view returns (Duration clockExtension_); + function closeGame() external; + function credit(address _recipient) external view returns (uint256 credit_); + function defend(Claim _disputed, uint256 _parentIndex, Claim _claim) external payable; + function getChallengerDuration(uint256 _claimIndex) external view returns (Duration duration_); + function getNumToResolve(uint256 _claimIndex) external view returns (uint256 numRemainingChildren_); + function getRequiredBond(Position _position) external view returns (uint256 requiredBond_); + function hasUnlockedCredit(address) external view returns (bool); + function maxClockDuration() external view returns (Duration maxClockDuration_); + function maxGameDepth() external view returns (uint256 maxGameDepth_); + function move(Claim _disputed, uint256 _challengeIndex, Claim _claim, bool _isAttack) external payable; + function normalModeCredit(address) external view returns (uint256); + function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); + function refundModeCredit(address) external view returns (uint256); + function resolutionCheckpoints(uint256) + external + view + returns (bool initialCheckpointComplete, uint32 subgameIndex, Position leftmostPosition, address counteredBy); // nosemgrep + function resolveClaim(uint256 _claimIndex, uint256 _numToResolve) external; + function resolvedSubgames(uint256) external view returns (bool); + function splitDepth() external view returns (uint256 splitDepth_); + function startingSequenceNumber() external view returns (uint256 startingSequenceNumber_); + function startingProposal() external view returns (Hash root, uint256 l2SequenceNumber); // nosemgrep + function startingRootHash() external view returns (Hash startingRootHash_); + function step(uint256 _claimIndex, bool _isAttack, bytes memory _stateData, bytes memory _proof) external; + function subgames(uint256, uint256) external view returns (uint256); + function version() external pure returns (string memory); + function vm() external view returns (IBigStepper vm_); + function wasRespectedGameTypeWhenCreated() external view returns (bool); + function weth() external view returns (IDelayedWETH weth_); + + function __constructor__(GameConstructorParams memory _params) external; +} diff --git a/packages/contracts-bedrock/lib/superchain-registry b/packages/contracts-bedrock/lib/superchain-registry index f5d8c509f02..84bce73573f 160000 --- a/packages/contracts-bedrock/lib/superchain-registry +++ b/packages/contracts-bedrock/lib/superchain-registry @@ -1 +1 @@ -Subproject commit f5d8c509f0241cb2c59f508a889db1980a60ad89 +Subproject commit 84bce73573f130008d84bae6e924163bab589a11 diff --git a/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol b/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol index c4a9e3d2f2f..b71b6dd3f3a 100644 --- a/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol @@ -28,7 +28,7 @@ import { Constants } from "src/libraries/Constants.sol"; import { Types } from "scripts/libraries/Types.sol"; import { Duration } from "src/dispute/lib/LibUDT.sol"; import { StorageSlot, ForgeArtifacts } from "scripts/libraries/ForgeArtifacts.sol"; -import { GameType, Claim, GameTypes, OutputRoot, Hash } from "src/dispute/lib/Types.sol"; +import { GameType, Claim, GameTypes, Proposal, Hash } from "src/dispute/lib/Types.sol"; // Interfaces import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; @@ -956,7 +956,7 @@ contract Deploy is Deployer { blobBasefeeScalar: cfg.blobbasefeeScalar(), l2ChainId: cfg.l2ChainID(), startingAnchorRoot: abi.encode( - OutputRoot({ root: Hash.wrap(cfg.faultGameGenesisOutputRoot()), l2BlockNumber: cfg.faultGameGenesisBlock() }) + Proposal({ root: Hash.wrap(cfg.faultGameGenesisOutputRoot()), l2SequenceNumber: cfg.faultGameGenesisBlock() }) ), saltMixer: saltMixer, gasLimit: uint64(cfg.l2GenesisBlockGasLimit()), diff --git a/packages/contracts-bedrock/scripts/libraries/Constants.sol b/packages/contracts-bedrock/scripts/libraries/Constants.sol index f98fdd32707..c7ba61822d3 100644 --- a/packages/contracts-bedrock/scripts/libraries/Constants.sol +++ b/packages/contracts-bedrock/scripts/libraries/Constants.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import { OutputRoot, Hash } from "src/dispute/lib/Types.sol"; +import { Proposal, Hash } from "src/dispute/lib/Types.sol"; /// @title Constants /// @notice Constants is a library for storing constants. Simple! Don't put everything in here, just @@ -9,7 +9,7 @@ import { OutputRoot, Hash } from "src/dispute/lib/Types.sol"; /// should be defined in that contract instead. library Constants { /// @notice Returns the default starting anchor roots value to be used in a new dispute game. - function DEFAULT_OUTPUT_ROOT() internal pure returns (OutputRoot memory) { - return OutputRoot({ root: Hash.wrap(bytes32(hex"dead")), l2BlockNumber: 0 }); + function DEFAULT_OUTPUT_ROOT() internal pure returns (Proposal memory) { + return Proposal({ root: Hash.wrap(bytes32(hex"dead")), l2SequenceNumber: 0 }); } } diff --git a/packages/contracts-bedrock/snapshots/abi/AnchorStateRegistry.json b/packages/contracts-bedrock/snapshots/abi/AnchorStateRegistry.json index 3aa3c26096c..0d98a33f225 100644 --- a/packages/contracts-bedrock/snapshots/abi/AnchorStateRegistry.json +++ b/packages/contracts-bedrock/snapshots/abi/AnchorStateRegistry.json @@ -144,11 +144,11 @@ }, { "internalType": "uint256", - "name": "l2BlockNumber", + "name": "l2SequenceNumber", "type": "uint256" } ], - "internalType": "struct OutputRoot", + "internalType": "struct Proposal", "name": "_startingAnchorRoot", "type": "tuple" }, diff --git a/packages/contracts-bedrock/snapshots/abi/FaultDisputeGame.json b/packages/contracts-bedrock/snapshots/abi/FaultDisputeGame.json index 3049ad62276..9ba78fac8b5 100644 --- a/packages/contracts-bedrock/snapshots/abi/FaultDisputeGame.json +++ b/packages/contracts-bedrock/snapshots/abi/FaultDisputeGame.json @@ -566,6 +566,19 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [], + "name": "l2SequenceNumber", + "outputs": [ + { + "internalType": "uint256", + "name": "l2SequenceNumber_", + "type": "uint256" + } + ], + "stateMutability": "pure", + "type": "function" + }, { "inputs": [], "name": "maxClockDuration", @@ -805,7 +818,7 @@ }, { "internalType": "uint256", - "name": "l2BlockNumber", + "name": "l2SequenceNumber", "type": "uint256" } ], diff --git a/packages/contracts-bedrock/snapshots/abi/PermissionedDisputeGame.json b/packages/contracts-bedrock/snapshots/abi/PermissionedDisputeGame.json index 8aa53d301a8..2bf04958bbe 100644 --- a/packages/contracts-bedrock/snapshots/abi/PermissionedDisputeGame.json +++ b/packages/contracts-bedrock/snapshots/abi/PermissionedDisputeGame.json @@ -589,6 +589,19 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [], + "name": "l2SequenceNumber", + "outputs": [ + { + "internalType": "uint256", + "name": "l2SequenceNumber_", + "type": "uint256" + } + ], + "stateMutability": "pure", + "type": "function" + }, { "inputs": [], "name": "maxClockDuration", @@ -841,7 +854,7 @@ }, { "internalType": "uint256", - "name": "l2BlockNumber", + "name": "l2SequenceNumber", "type": "uint256" } ], diff --git a/packages/contracts-bedrock/snapshots/abi/SuperFaultDisputeGame.json b/packages/contracts-bedrock/snapshots/abi/SuperFaultDisputeGame.json index 8c72cb9c74c..0dda8da865f 100644 --- a/packages/contracts-bedrock/snapshots/abi/SuperFaultDisputeGame.json +++ b/packages/contracts-bedrock/snapshots/abi/SuperFaultDisputeGame.json @@ -476,11 +476,11 @@ }, { "inputs": [], - "name": "l2BlockNumber", + "name": "l2SequenceNumber", "outputs": [ { "internalType": "uint256", - "name": "l2BlockNumber_", + "name": "l2SequenceNumber_", "type": "uint256" } ], @@ -704,11 +704,16 @@ }, { "inputs": [], - "name": "startingBlockNumber", + "name": "startingProposal", "outputs": [ + { + "internalType": "Hash", + "name": "root", + "type": "bytes32" + }, { "internalType": "uint256", - "name": "startingBlockNumber_", + "name": "l2SequenceNumber", "type": "uint256" } ], @@ -717,17 +722,12 @@ }, { "inputs": [], - "name": "startingOutputRoot", + "name": "startingRootHash", "outputs": [ { "internalType": "Hash", - "name": "root", + "name": "startingRootHash_", "type": "bytes32" - }, - { - "internalType": "uint256", - "name": "l2BlockNumber", - "type": "uint256" } ], "stateMutability": "view", @@ -735,12 +735,12 @@ }, { "inputs": [], - "name": "startingRootHash", + "name": "startingSequenceNumber", "outputs": [ { - "internalType": "Hash", - "name": "startingRootHash_", - "type": "bytes32" + "internalType": "uint256", + "name": "startingSequenceNumber_", + "type": "uint256" } ], "stateMutability": "view", diff --git a/packages/contracts-bedrock/snapshots/abi/SuperPermissionedDisputeGame.json b/packages/contracts-bedrock/snapshots/abi/SuperPermissionedDisputeGame.json index 02de35aca29..227c2edc06c 100644 --- a/packages/contracts-bedrock/snapshots/abi/SuperPermissionedDisputeGame.json +++ b/packages/contracts-bedrock/snapshots/abi/SuperPermissionedDisputeGame.json @@ -499,11 +499,11 @@ }, { "inputs": [], - "name": "l2BlockNumber", + "name": "l2SequenceNumber", "outputs": [ { "internalType": "uint256", - "name": "l2BlockNumber_", + "name": "l2SequenceNumber_", "type": "uint256" } ], @@ -740,11 +740,16 @@ }, { "inputs": [], - "name": "startingBlockNumber", + "name": "startingProposal", "outputs": [ + { + "internalType": "Hash", + "name": "root", + "type": "bytes32" + }, { "internalType": "uint256", - "name": "startingBlockNumber_", + "name": "l2SequenceNumber", "type": "uint256" } ], @@ -753,17 +758,12 @@ }, { "inputs": [], - "name": "startingOutputRoot", + "name": "startingRootHash", "outputs": [ { "internalType": "Hash", - "name": "root", + "name": "startingRootHash_", "type": "bytes32" - }, - { - "internalType": "uint256", - "name": "l2BlockNumber", - "type": "uint256" } ], "stateMutability": "view", @@ -771,12 +771,12 @@ }, { "inputs": [], - "name": "startingRootHash", + "name": "startingSequenceNumber", "outputs": [ { - "internalType": "Hash", - "name": "startingRootHash_", - "type": "bytes32" + "internalType": "uint256", + "name": "startingSequenceNumber_", + "type": "uint256" } ], "stateMutability": "view", diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index 8aaad256ffc..87586ad2a58 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -20,8 +20,8 @@ "sourceCodeHash": "0x44797707aea8c63dec049a02d69ea056662a06e5cf320028ab8b388634bf1c67" }, "src/L1/OPContractsManager.sol:OPContractsManager": { - "initCodeHash": "0xaa8ca04a37dfcc419f5fc53f0411e5a7bd772b88d4df5da7558aaceea26547d1", - "sourceCodeHash": "0x11f9627893eabb8f81c538a79d55abffb0c37bef6e8d1121b085fac4008726c9" + "initCodeHash": "0x4c4cd28e0942b7a9c25152f5af1e67d0c301d2c017aa2c01b91d0646b255984c", + "sourceCodeHash": "0xcce6d86f7988147942ad3bac6a8bbaf1aa576cd4dd7f81716a944620770012a3" }, "src/L1/OptimismPortal2.sol:OptimismPortal2": { "initCodeHash": "0xbc7db7b1016025228d99a40db1760290b333bb90563dff5514fd253fd91019ba", @@ -152,8 +152,8 @@ "sourceCodeHash": "0x03c160168986ffc8d26a90c37366e7ad6da03f49d83449e1f8b3de0f4b590f6f" }, "src/dispute/AnchorStateRegistry.sol:AnchorStateRegistry": { - "initCodeHash": "0xb905a31a816dc7354e9153a6cbf08d968c6d631e5383bd64c5ff1825bf284825", - "sourceCodeHash": "0xf785b369133782f614ed792766f5ec05d79b639db29abc2af2a4074f8600fb36" + "initCodeHash": "0x38a6746412f59e12d279c23ac6c620b2c306c117532d2299d511808851488bbd", + "sourceCodeHash": "0x2e64207064472cfdae29fb4f7499ae49fd76ef6cb4c51babd15679432d6a14f6" }, "src/dispute/DelayedWETH.sol:DelayedWETH": { "initCodeHash": "0xdd0b5e523f3b53563fe0b6e6165fb73605b14910ffa32a7cbed855cdebab47c6", @@ -164,20 +164,20 @@ "sourceCodeHash": "0x08efbce44394f555a4e656816897029e2e80e455e4200a1b887fc18993294660" }, "src/dispute/FaultDisputeGame.sol:FaultDisputeGame": { - "initCodeHash": "0xd86a649deaa0d5ca6c4b60afb941c52fd2b5d10857657defda3629faaff6d77e", - "sourceCodeHash": "0xf5d3760949af227ea161f552a1d0c5d605a26bfd24dc428f674c011cb7f0a416" + "initCodeHash": "0xcf599cfd92543953cb3ccf3127aa095cb2752e872cdd3953d17821b7716e72c0", + "sourceCodeHash": "0x41058e11ea000b6f0aaf925d0f05c2ed7b6ab38c83594dd44f6fb5d6b9f671a6" }, "src/dispute/PermissionedDisputeGame.sol:PermissionedDisputeGame": { - "initCodeHash": "0x63ab07ca14b77da770de1814b112e1a21ea984c5132b8ff3beaab2cf88018c19", - "sourceCodeHash": "0xba32e6f35777426839a60e5556c09844e805eaabc14b9d3732cc64f2a99ce7fc" + "initCodeHash": "0x7ad9fd33a79a43877ea204a5f75aa6a870da2ab9cbfce96cbc14dc4ddff7164b", + "sourceCodeHash": "0x88571b2360f58fd648e70289d828781d4f29007b3f6005b5a9cacf5353a3ecbf" }, "src/dispute/SuperFaultDisputeGame.sol:SuperFaultDisputeGame": { - "initCodeHash": "0x397d9eda98459859f30f170f0d3c6f4320d474ea36510ae7ece020800b80ba22", - "sourceCodeHash": "0xb08789200c909d24c8ebfbde9b9c55c50b9ebae2d21e761464c1b5abbbe59317" + "initCodeHash": "0x25a4e28d12b7a6885a8f50ef182775005339efa0010897affe0f44325fbbfcac", + "sourceCodeHash": "0xe0094f825c433e6d34b2ef1fa6f2aefc5603ac7f83ce1348444ba9af706f9a3f" }, "src/dispute/SuperPermissionedDisputeGame.sol:SuperPermissionedDisputeGame": { - "initCodeHash": "0x9613232c1c11abee8782e2e9a5bb963923c73643d8c228e558f06082e8886f67", - "sourceCodeHash": "0xaefa8af211cee1b34063252f62020cd468175a2ab9cfc46b4e4cb03190e2d659" + "initCodeHash": "0xaf43915296e333361835fbd8a74342e4e84a467f860cb5fd25bd773b672e2bbc", + "sourceCodeHash": "0xdbae9a8ea6aca8b4f8a5f9559e3a1d254153dd89ef3984a84f8ff6aeaa8020b3" }, "src/legacy/DeployerWhitelist.sol:DeployerWhitelist": { "initCodeHash": "0x53099379ed48b87f027d55712dbdd1da7d7099925426eb0531da9c0012e02c29", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/AnchorStateRegistry.json b/packages/contracts-bedrock/snapshots/storageLayout/AnchorStateRegistry.json index 4d981001f8f..1a1e86085b2 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/AnchorStateRegistry.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/AnchorStateRegistry.json @@ -39,7 +39,7 @@ "label": "startingAnchorRoot", "offset": 0, "slot": "3", - "type": "struct OutputRoot" + "type": "struct Proposal" }, { "bytes": "32", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/FaultDisputeGame.json b/packages/contracts-bedrock/snapshots/storageLayout/FaultDisputeGame.json index 85a5897c020..02c6e21ec5f 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/FaultDisputeGame.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/FaultDisputeGame.json @@ -88,7 +88,7 @@ "label": "startingOutputRoot", "offset": 0, "slot": "8", - "type": "struct OutputRoot" + "type": "struct Proposal" }, { "bytes": "1", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/PermissionedDisputeGame.json b/packages/contracts-bedrock/snapshots/storageLayout/PermissionedDisputeGame.json index 85a5897c020..02c6e21ec5f 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/PermissionedDisputeGame.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/PermissionedDisputeGame.json @@ -88,7 +88,7 @@ "label": "startingOutputRoot", "offset": 0, "slot": "8", - "type": "struct OutputRoot" + "type": "struct Proposal" }, { "bytes": "1", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/SuperFaultDisputeGame.json b/packages/contracts-bedrock/snapshots/storageLayout/SuperFaultDisputeGame.json index 62bd48ce754..8764cfaf1ba 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/SuperFaultDisputeGame.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/SuperFaultDisputeGame.json @@ -71,10 +71,10 @@ }, { "bytes": "64", - "label": "startingOutputRoot", + "label": "startingProposal", "offset": 0, "slot": "7", - "type": "struct OutputRoot" + "type": "struct Proposal" }, { "bytes": "1", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/SuperPermissionedDisputeGame.json b/packages/contracts-bedrock/snapshots/storageLayout/SuperPermissionedDisputeGame.json index 62bd48ce754..8764cfaf1ba 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/SuperPermissionedDisputeGame.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/SuperPermissionedDisputeGame.json @@ -71,10 +71,10 @@ }, { "bytes": "64", - "label": "startingOutputRoot", + "label": "startingProposal", "offset": 0, "slot": "7", - "type": "struct OutputRoot" + "type": "struct Proposal" }, { "bytes": "1", diff --git a/packages/contracts-bedrock/src/L1/OPContractsManager.sol b/packages/contracts-bedrock/src/L1/OPContractsManager.sol index c67f9370820..f30d26b4c20 100644 --- a/packages/contracts-bedrock/src/L1/OPContractsManager.sol +++ b/packages/contracts-bedrock/src/L1/OPContractsManager.sol @@ -5,7 +5,7 @@ pragma solidity 0.8.15; import { Blueprint } from "src/libraries/Blueprint.sol"; import { Constants } from "src/libraries/Constants.sol"; import { Bytes } from "src/libraries/Bytes.sol"; -import { Claim, Duration, GameType, GameTypes, OutputRoot, Hash } from "src/dispute/lib/Types.sol"; +import { Claim, Duration, GameType, Hash, GameTypes, Proposal } from "src/dispute/lib/Types.sol"; import { Strings } from "@openzeppelin/contracts/utils/Strings.sol"; // Interfaces @@ -593,7 +593,7 @@ contract OPContractsManagerUpgrader is OPContractsManagerBase { ( superchainConfig, dgf, - OutputRoot({ root: root, l2BlockNumber: l2BlockNumber }), + Proposal({ root: root, l2SequenceNumber: l2BlockNumber }), respectedGameType ) ) @@ -1154,7 +1154,7 @@ contract OPContractsManagerDeployer is OPContractsManagerBase { virtual returns (bytes memory) { - OutputRoot memory startingAnchorRoot = abi.decode(_input.startingAnchorRoot, (OutputRoot)); + Proposal memory startingAnchorRoot = abi.decode(_input.startingAnchorRoot, (Proposal)); return abi.encodeCall( IAnchorStateRegistry.initialize, (_superchainConfig, _output.disputeGameFactoryProxy, startingAnchorRoot, GameTypes.PERMISSIONED_CANNON) @@ -1193,7 +1193,7 @@ contract OPContractsManager is ISemver { uint32 basefeeScalar; uint32 blobBasefeeScalar; uint256 l2ChainId; - // The correct type is OutputRoot memory but OP Deployer does not yet support structs. + // The correct type is Proposal memory but OP Deployer does not yet support structs. bytes startingAnchorRoot; // The salt mixer is used as part of making the resulting salt unique. string saltMixer; @@ -1291,9 +1291,9 @@ contract OPContractsManager is ISemver { // -------- Constants and Variables -------- - /// @custom:semver 1.12.0 + /// @custom:semver 1.12.1 function version() public pure virtual returns (string memory) { - return "1.12.0"; + return "1.12.1"; } OPContractsManagerGameTypeAdder public immutable opcmGameTypeAdder; diff --git a/packages/contracts-bedrock/src/dispute/AnchorStateRegistry.sol b/packages/contracts-bedrock/src/dispute/AnchorStateRegistry.sol index 35b9d2736fb..4368e44d0a1 100644 --- a/packages/contracts-bedrock/src/dispute/AnchorStateRegistry.sol +++ b/packages/contracts-bedrock/src/dispute/AnchorStateRegistry.sol @@ -5,7 +5,7 @@ pragma solidity 0.8.15; import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable.sol"; // Libraries -import { GameType, OutputRoot, Claim, GameStatus, Hash } from "src/dispute/lib/Types.sol"; +import { GameType, Proposal, Claim, GameStatus, Hash } from "src/dispute/lib/Types.sol"; // Interfaces import { ISemver } from "interfaces/universal/ISemver.sol"; @@ -22,8 +22,8 @@ import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; /// be initialized with a more recent starting state which reduces the amount of required offchain computation. contract AnchorStateRegistry is Initializable, ISemver { /// @notice Semantic version. - /// @custom:semver 3.0.0 - string public constant version = "3.0.0"; + /// @custom:semver 3.1.0 + string public constant version = "3.1.0"; /// @notice The dispute game finality delay in seconds. uint256 internal immutable DISPUTE_GAME_FINALITY_DELAY_SECONDS; @@ -38,7 +38,7 @@ contract AnchorStateRegistry is Initializable, ISemver { IFaultDisputeGame public anchorGame; /// @notice The starting anchor root. - OutputRoot internal startingAnchorRoot; + Proposal internal startingAnchorRoot; /// @notice Mapping of blacklisted dispute games. mapping(IDisputeGame => bool) public disputeGameBlacklist; @@ -89,7 +89,7 @@ contract AnchorStateRegistry is Initializable, ISemver { function initialize( ISuperchainConfig _superchainConfig, IDisputeGameFactory _disputeGameFactory, - OutputRoot memory _startingAnchorRoot, + Proposal memory _startingAnchorRoot, GameType _startingRespectedGameType ) external @@ -149,11 +149,11 @@ contract AnchorStateRegistry is Initializable, ISemver { function getAnchorRoot() public view returns (Hash, uint256) { // Return the starting anchor root if there is no anchor game. if (address(anchorGame) == address(0)) { - return (startingAnchorRoot.root, startingAnchorRoot.l2BlockNumber); + return (startingAnchorRoot.root, startingAnchorRoot.l2SequenceNumber); } // Otherwise, return the anchor root. - return (Hash.wrap(anchorGame.rootClaim().raw()), anchorGame.l2BlockNumber()); + return (Hash.wrap(anchorGame.rootClaim().raw()), anchorGame.l2SequenceNumber()); } /// @notice Determines whether a game is registered in the DisputeGameFactory. @@ -305,7 +305,7 @@ contract AnchorStateRegistry is Initializable, ISemver { // Must be newer than the current anchor game. (, uint256 anchorL2BlockNumber) = getAnchorRoot(); - if (game.l2BlockNumber() <= anchorL2BlockNumber) { + if (game.l2SequenceNumber() <= anchorL2BlockNumber) { revert AnchorStateRegistry_InvalidAnchorGame(); } diff --git a/packages/contracts-bedrock/src/dispute/FaultDisputeGame.sol b/packages/contracts-bedrock/src/dispute/FaultDisputeGame.sol index 2ee9bcd58c6..09314a013a3 100644 --- a/packages/contracts-bedrock/src/dispute/FaultDisputeGame.sol +++ b/packages/contracts-bedrock/src/dispute/FaultDisputeGame.sol @@ -17,7 +17,7 @@ import { Duration, Timestamp, Hash, - OutputRoot, + Proposal, LibClock, LocalPreimageKey, VMStatuses @@ -170,9 +170,9 @@ contract FaultDisputeGame is Clone, ISemver { uint256 internal constant HEADER_BLOCK_NUMBER_INDEX = 8; /// @notice Semantic version. - /// @custom:semver 1.4.1 + /// @custom:semver 1.5.0 function version() public pure virtual returns (string memory) { - return "1.4.1"; + return "1.5.0"; } /// @notice The starting timestamp of the game @@ -213,7 +213,7 @@ contract FaultDisputeGame is Clone, ISemver { mapping(uint256 => ResolutionCheckpoint) public resolutionCheckpoints; /// @notice The latest finalized output root, serving as the anchor for output bisection. - OutputRoot public startingOutputRoot; + Proposal public startingOutputRoot; /// @notice A boolean for whether or not the game type was respected when the game was created. bool public wasRespectedGameTypeWhenCreated; @@ -302,8 +302,8 @@ contract FaultDisputeGame is Clone, ISemver { // Should only happen if this is a new game type that hasn't been set up yet. if (root.raw() == bytes32(0)) revert AnchorRootNotFound(); - // Set the starting output root. - startingOutputRoot = OutputRoot({ l2BlockNumber: rootBlockNumber, root: root }); + // Set the starting proposal. + startingOutputRoot = Proposal({ l2SequenceNumber: rootBlockNumber, root: root }); // Revert if the calldata size is not the expected length. // @@ -616,7 +616,7 @@ contract FaultDisputeGame is Clone, ISemver { // We add the index at depth + 1 to the starting block number to get the disputed L2 // block number. - uint256 l2Number = startingOutputRoot.l2BlockNumber + disputedPos.traceIndex(SPLIT_DEPTH) + 1; + uint256 l2Number = startingOutputRoot.l2SequenceNumber + disputedPos.traceIndex(SPLIT_DEPTH) + 1; // Choose the minimum between the `l2BlockNumber` claim and the bisected-to L2 block number. l2Number = l2Number < l2BlockNumber() ? l2Number : l2BlockNumber(); @@ -647,9 +647,14 @@ contract FaultDisputeGame is Clone, ISemver { l2BlockNumber_ = _getArgUint256(0x54); } + /// @notice The l2SequenceNumber of the disputed output root in the `L2OutputOracle` (in this case - block number). + function l2SequenceNumber() public pure returns (uint256 l2SequenceNumber_) { + l2SequenceNumber_ = l2BlockNumber(); + } + /// @notice Only the starting block number of the game. function startingBlockNumber() external view returns (uint256 startingBlockNumber_) { - startingBlockNumber_ = startingOutputRoot.l2BlockNumber; + startingBlockNumber_ = startingOutputRoot.l2SequenceNumber; } /// @notice Starting output root and block number of the game. diff --git a/packages/contracts-bedrock/src/dispute/PermissionedDisputeGame.sol b/packages/contracts-bedrock/src/dispute/PermissionedDisputeGame.sol index f12fb2fce29..0e1c8a55284 100644 --- a/packages/contracts-bedrock/src/dispute/PermissionedDisputeGame.sol +++ b/packages/contracts-bedrock/src/dispute/PermissionedDisputeGame.sol @@ -32,9 +32,9 @@ contract PermissionedDisputeGame is FaultDisputeGame { } /// @notice Semantic version. - /// @custom:semver 1.4.1 + /// @custom:semver 1.5.0 function version() public pure override returns (string memory) { - return "1.4.1"; + return "1.5.0"; } /// @param _params Parameters for creating a new FaultDisputeGame. diff --git a/packages/contracts-bedrock/src/dispute/SuperFaultDisputeGame.sol b/packages/contracts-bedrock/src/dispute/SuperFaultDisputeGame.sol index bd96a4b4068..f08df98f094 100644 --- a/packages/contracts-bedrock/src/dispute/SuperFaultDisputeGame.sol +++ b/packages/contracts-bedrock/src/dispute/SuperFaultDisputeGame.sol @@ -14,7 +14,7 @@ import { Duration, Timestamp, Hash, - OutputRoot, + Proposal, LibClock, LocalPreimageKey, VMStatuses @@ -163,9 +163,9 @@ contract SuperFaultDisputeGame is Clone, ISemver { Position internal constant ROOT_POSITION = Position.wrap(1); /// @notice Semantic version. - /// @custom:semver 0.1.0-beta.1 + /// @custom:semver 0.2.0-beta.1 function version() public pure virtual returns (string memory) { - return "0.1.0-beta.1"; + return "0.2.0-beta.1"; } /// @notice The starting timestamp of the game @@ -199,7 +199,7 @@ contract SuperFaultDisputeGame is Clone, ISemver { mapping(uint256 => ResolutionCheckpoint) public resolutionCheckpoints; /// @notice The latest finalized output root, serving as the anchor for output bisection. - OutputRoot public startingOutputRoot; + Proposal public startingProposal; /// @notice A boolean for whether or not the game type was respected when the game was created. bool public wasRespectedGameTypeWhenCreated; @@ -278,7 +278,7 @@ contract SuperFaultDisputeGame is Clone, ISemver { // // Explicit checks: // - The game must not have already been initialized. - // - An output root cannot be proposed at or before the starting block number. + // - An output root cannot be proposed at or before the starting l2SequenceNumber. // INVARIANT: The game must not have already been initialized. if (initialized) revert AlreadyInitialized(); @@ -292,8 +292,8 @@ contract SuperFaultDisputeGame is Clone, ISemver { // Prevent initializing right away with an invalid claim state that is used as convention if (rootClaim().raw() == INVALID_ROOT_CLAIM) revert SuperFaultDisputeGameInvalidRootClaim(); - // Set the starting output root. - startingOutputRoot = OutputRoot({ l2BlockNumber: rootBlockNumber, root: root }); + // Set the starting Proposal. + startingProposal = Proposal({ l2SequenceNumber: rootBlockNumber, root: root }); // Revert if the calldata size is not the expected length. // @@ -318,7 +318,7 @@ contract SuperFaultDisputeGame is Clone, ISemver { // Do not allow the game to be initialized if the root claim corresponds to a block at or before the // configured starting block number. - if (l2BlockNumber() <= rootBlockNumber) revert UnexpectedRootClaim(rootClaim()); + if (l2SequenceNumber() <= rootBlockNumber) revert UnexpectedRootClaim(rootClaim()); // Set the root claim claimData.push( @@ -597,7 +597,7 @@ contract SuperFaultDisputeGame is Clone, ISemver { // Load the disputed proposal's output root oracle.loadLocalData(_ident, uuid.raw(), disputed.raw(), 32, _partOffset); } else if (_ident == LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER) { - oracle.loadLocalData(_ident, uuid.raw(), bytes32(l2BlockNumber() << 0xC0), 8, _partOffset); + oracle.loadLocalData(_ident, uuid.raw(), bytes32(l2SequenceNumber() << 0xC0), 8, _partOffset); } else { revert InvalidLocalIdent(); } @@ -615,19 +615,19 @@ contract SuperFaultDisputeGame is Clone, ISemver { numRemainingChildren_ = challengeIndicesLen - checkpoint.subgameIndex; } - /// @notice The l2BlockNumber of the disputed output root in the `L2OutputOracle`. - function l2BlockNumber() public pure returns (uint256 l2BlockNumber_) { - l2BlockNumber_ = _getArgUint256(0x54); + /// @notice The l2SequenceNumber (timestamp) of the disputed super root in game root claim. + function l2SequenceNumber() public pure returns (uint256 l2SequenceNumber_) { + l2SequenceNumber_ = _getArgUint256(0x54); } /// @notice Only the starting block number of the game. - function startingBlockNumber() external view returns (uint256 startingBlockNumber_) { - startingBlockNumber_ = startingOutputRoot.l2BlockNumber; + function startingSequenceNumber() external view returns (uint256 startingSequenceNumber_) { + startingSequenceNumber_ = startingProposal.l2SequenceNumber; } - /// @notice Starting output root and block number of the game. + /// @notice Starting super root and block number of the game. function startingRootHash() external view returns (Hash startingRootHash_) { - startingRootHash_ = startingOutputRoot.root; + startingRootHash_ = startingProposal.root; } //////////////////////////////////////////////////////////////// @@ -1060,7 +1060,7 @@ contract SuperFaultDisputeGame is Clone, ISemver { view { // The root claim of an execution trace bisection sub-game must: - // 1. Signal that the VM panicked or resulted in an invalid transition if the disputed output root + // 1. Signal that the VM panicked or resulted in an invalid transition if the disputed super root // was made by the opposing party. // 2. Signal that the VM resulted in a valid transition if the disputed output root was made by the same party. @@ -1169,7 +1169,7 @@ contract SuperFaultDisputeGame is Clone, ISemver { ClaimData storage starting = _findTraceAncestor(Position.wrap(outputPos.raw() - 1), claimIdx, true); (startingClaim_, startingPos_) = (starting.claim, starting.position); } else { - startingClaim_ = Claim.wrap(startingOutputRoot.root.raw()); + startingClaim_ = Claim.wrap(startingProposal.root.raw()); } (disputedClaim_, disputedPos_) = (claim.claim, claim.position); } else { diff --git a/packages/contracts-bedrock/src/dispute/SuperPermissionedDisputeGame.sol b/packages/contracts-bedrock/src/dispute/SuperPermissionedDisputeGame.sol index 1042408de74..deb9f3f1ecf 100644 --- a/packages/contracts-bedrock/src/dispute/SuperPermissionedDisputeGame.sol +++ b/packages/contracts-bedrock/src/dispute/SuperPermissionedDisputeGame.sol @@ -33,9 +33,9 @@ contract SuperPermissionedDisputeGame is SuperFaultDisputeGame { } /// @notice Semantic version. - /// @custom:semver 0.1.0-beta.1 + /// @custom:semver 0.2.0-beta.1 function version() public pure override returns (string memory) { - return "0.1.0-beta.1"; + return "0.2.0-beta.1"; } /// @param _params Parameters for creating a new FaultDisputeGame. diff --git a/packages/contracts-bedrock/src/dispute/lib/Types.sol b/packages/contracts-bedrock/src/dispute/lib/Types.sol index 18c197836ad..35da47eb62b 100644 --- a/packages/contracts-bedrock/src/dispute/lib/Types.sol +++ b/packages/contracts-bedrock/src/dispute/lib/Types.sol @@ -37,12 +37,13 @@ enum BondDistributionMode { REFUND } -/// @notice Represents an L2 output root and the L2 block number at which it was generated. +/// @notice Represents an L2 root and the L2 sequence number at which it was generated. /// @custom:field root The output root. -/// @custom:field l2BlockNumber The L2 block number at which the output root was generated. -struct OutputRoot { +/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was +/// generated. +struct Proposal { Hash root; - uint256 l2BlockNumber; + uint256 l2SequenceNumber; } /// @title GameTypes diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index c4856ca36ba..ee8bbb7c844 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -60,7 +60,7 @@ import { import { Blueprint } from "src/libraries/Blueprint.sol"; import { IBigStepper } from "interfaces/dispute/IBigStepper.sol"; import { GameType, Duration, Hash, Claim } from "src/dispute/lib/LibUDT.sol"; -import { OutputRoot, GameTypes } from "src/dispute/lib/Types.sol"; +import { Proposal, GameTypes } from "src/dispute/lib/Types.sol"; // Exposes internal functions for testing. contract OPContractsManager_Harness is OPContractsManager { @@ -573,13 +573,13 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { // Check that the PermissionedDisputeGame is upgraded to the expected version, references // the correct anchor state and has the mipsImpl. Although Upgrade 15 doesn't actually // change any of this, we might as well check it again. - assertEq(ISemver(address(pdg)).version(), "1.4.1"); + assertEq(ISemver(address(pdg)).version(), "1.5.0"); assertEq(address(pdg.vm()), impls.mipsImpl); assertEq(pdg.l2ChainId(), oldPDG.l2ChainId()); // If the old FaultDisputeGame exists, we expect it to be upgraded. Check same as above. if (address(oldFDG) != address(0)) { - assertEq(ISemver(address(fdg)).version(), "1.4.1"); + assertEq(ISemver(address(fdg)).version(), "1.5.0"); assertEq(address(fdg.vm()), impls.mipsImpl); assertEq(fdg.l2ChainId(), oldFDG.l2ChainId()); } @@ -604,7 +604,7 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { }); // Make sure the new AnchorStateRegistry has the right version and is initialized. - assertEq(ISemver(address(newAsrProxy)).version(), "3.0.0"); + assertEq(ISemver(address(newAsrProxy)).version(), "3.1.0"); vm.prank(address(proxyAdmin)); assertEq(IProxy(payable(newAsrProxy)).admin(), address(proxyAdmin)); DeployUtils.assertInitialized({ _contractAddress: address(newAsrProxy), _isProxy: true, _slot: 0, _offset: 0 }); @@ -1021,9 +1021,9 @@ contract OPContractsManager_AddGameType_Test is Test { basefeeScalar: 1, blobBasefeeScalar: 1, startingAnchorRoot: abi.encode( - OutputRoot({ + Proposal({ root: Hash.wrap(0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef), - l2BlockNumber: 0 + l2SequenceNumber: 0 }) ), l2ChainId: 100, @@ -1377,9 +1377,9 @@ contract OPContractsManager_UpdatePrestate_Test is Test { basefeeScalar: 1, blobBasefeeScalar: 1, startingAnchorRoot: abi.encode( - OutputRoot({ + Proposal({ root: Hash.wrap(0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef), - l2BlockNumber: 0 + l2SequenceNumber: 0 }) ), l2ChainId: 100, diff --git a/packages/contracts-bedrock/test/dispute/AnchorStateRegistry.t.sol b/packages/contracts-bedrock/test/dispute/AnchorStateRegistry.t.sol index c171d97737e..58cb5b7afe0 100644 --- a/packages/contracts-bedrock/test/dispute/AnchorStateRegistry.t.sol +++ b/packages/contracts-bedrock/test/dispute/AnchorStateRegistry.t.sol @@ -5,7 +5,7 @@ pragma solidity ^0.8.15; import { FaultDisputeGame_Init, _changeClaimStatus } from "test/dispute/FaultDisputeGame.t.sol"; // Libraries -import { GameType, GameStatus, Hash, Claim, VMStatuses, OutputRoot } from "src/dispute/lib/Types.sol"; +import { GameType, GameStatus, Hash, Claim, VMStatuses, Proposal } from "src/dispute/lib/Types.sol"; // Interfaces import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; @@ -58,9 +58,9 @@ contract AnchorStateRegistry_Initialize_TestFail is AnchorStateRegistry_Init { anchorStateRegistry.initialize( superchainConfig, disputeGameFactory, - OutputRoot({ + Proposal({ root: Hash.wrap(0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF), - l2BlockNumber: 0 + l2SequenceNumber: 0 }), GameType.wrap(0) ); @@ -123,7 +123,7 @@ contract AnchorStateRegistry_GetAnchorRoot_Test is AnchorStateRegistry_Init { // We should get the anchor root back. (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.getAnchorRoot(); assertEq(root.raw(), gameProxy.rootClaim().raw()); - assertEq(l2BlockNumber, gameProxy.l2BlockNumber()); + assertEq(l2BlockNumber, gameProxy.l2SequenceNumber()); } /// @notice Tests that getAnchorRoot will return the latest anchor root even if the superchain @@ -146,7 +146,7 @@ contract AnchorStateRegistry_GetAnchorRoot_Test is AnchorStateRegistry_Init { // We should get the anchor root back. (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.getAnchorRoot(); assertEq(root.raw(), gameProxy.rootClaim().raw()); - assertEq(l2BlockNumber, gameProxy.l2BlockNumber()); + assertEq(l2BlockNumber, gameProxy.l2SequenceNumber()); } /// @notice Tests that getAnchorRoot returns even if the anchor game is blacklisted. @@ -168,7 +168,7 @@ contract AnchorStateRegistry_GetAnchorRoot_Test is AnchorStateRegistry_Init { // Get the anchor root. (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.getAnchorRoot(); assertEq(root.raw(), gameProxy.rootClaim().raw()); - assertEq(l2BlockNumber, gameProxy.l2BlockNumber()); + assertEq(l2BlockNumber, gameProxy.l2SequenceNumber()); } } @@ -602,7 +602,7 @@ contract AnchorStateRegistry_SetAnchorState_Test is AnchorStateRegistry_Init { _l2BlockNumber = bound(_l2BlockNumber, validL2BlockNumber, type(uint256).max); // Mock the l2BlockNumber call. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2BlockNumber, ()), abi.encode(_l2BlockNumber)); + vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(_l2BlockNumber)); // Mock the DEFENDER_WINS state. vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.status, ()), abi.encode(GameStatus.DEFENDER_WINS)); @@ -622,7 +622,7 @@ contract AnchorStateRegistry_SetAnchorState_Test is AnchorStateRegistry_Init { // Confirm that the anchor state is now the same as the game state. (root, l2BlockNumber) = anchorStateRegistry.getAnchorRoot(); - assertEq(l2BlockNumber, gameProxy.l2BlockNumber()); + assertEq(l2BlockNumber, gameProxy.l2SequenceNumber()); assertEq(root.raw(), gameProxy.rootClaim().raw()); // Confirm that the anchor game is now set. @@ -643,7 +643,7 @@ contract AnchorStateRegistry_SetAnchorState_TestFail is AnchorStateRegistry_Init _l2BlockNumber = bound(_l2BlockNumber, 0, l2BlockNumber); // Mock the l2BlockNumber call. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2BlockNumber, ()), abi.encode(_l2BlockNumber)); + vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(_l2BlockNumber)); // Mock the DEFENDER_WINS state. vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.status, ()), abi.encode(GameStatus.DEFENDER_WINS)); @@ -676,7 +676,7 @@ contract AnchorStateRegistry_SetAnchorState_TestFail is AnchorStateRegistry_Init _l2BlockNumber = bound(_l2BlockNumber, l2BlockNumber, type(uint256).max); // Mock the l2BlockNumber call. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2BlockNumber, ()), abi.encode(_l2BlockNumber)); + vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(_l2BlockNumber)); // Mock the DEFENDER_WINS state. vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.status, ()), abi.encode(GameStatus.DEFENDER_WINS)); @@ -715,7 +715,7 @@ contract AnchorStateRegistry_SetAnchorState_TestFail is AnchorStateRegistry_Init _l2BlockNumber = bound(_l2BlockNumber, l2BlockNumber, type(uint256).max); // Mock the l2BlockNumber call. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2BlockNumber, ()), abi.encode(_l2BlockNumber)); + vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(_l2BlockNumber)); // Mock the CHALLENGER_WINS state. vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.status, ()), abi.encode(GameStatus.CHALLENGER_WINS)); @@ -749,7 +749,7 @@ contract AnchorStateRegistry_SetAnchorState_TestFail is AnchorStateRegistry_Init _l2BlockNumber = bound(_l2BlockNumber, l2BlockNumber, type(uint256).max); // Mock the l2BlockNumber call. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2BlockNumber, ()), abi.encode(_l2BlockNumber)); + vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(_l2BlockNumber)); // Mock the CHALLENGER_WINS state. vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.status, ()), abi.encode(GameStatus.IN_PROGRESS)); @@ -782,7 +782,7 @@ contract AnchorStateRegistry_SetAnchorState_TestFail is AnchorStateRegistry_Init _l2BlockNumber = bound(_l2BlockNumber, l2BlockNumber, type(uint256).max); // Mock the l2BlockNumber call. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2BlockNumber, ()), abi.encode(_l2BlockNumber)); + vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(_l2BlockNumber)); // Mock the DEFENDER_WINS state. vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.status, ()), abi.encode(GameStatus.DEFENDER_WINS)); diff --git a/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol b/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol index a655fcf12f3..5c681b05328 100644 --- a/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol +++ b/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol @@ -1855,14 +1855,14 @@ contract FaultDisputeGame_Test is FaultDisputeGame_Init { /// resolves in favor of the defender but the game state is not newer than the anchor state. function test_resolve_validOlderStateSameAnchor_succeeds() public { // Mock the game block to be older than the game state. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2BlockNumber, ()), abi.encode(0)); + vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(0)); // Confirm that the anchor state is newer than the game state. (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assert(l2BlockNumber >= gameProxy.l2BlockNumber()); + assert(l2BlockNumber >= gameProxy.l2SequenceNumber()); // Resolve the game. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2BlockNumber, ()), abi.encode(0)); + vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(0)); vm.warp(block.timestamp + 3 days + 12 hours); gameProxy.resolveClaim(0, 0); assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.DEFENDER_WINS)); diff --git a/packages/contracts-bedrock/test/dispute/SuperFaultDisputeGame.t.sol b/packages/contracts-bedrock/test/dispute/SuperFaultDisputeGame.t.sol index 919deaa2c96..5cf181ea12c 100644 --- a/packages/contracts-bedrock/test/dispute/SuperFaultDisputeGame.t.sol +++ b/packages/contracts-bedrock/test/dispute/SuperFaultDisputeGame.t.sol @@ -27,6 +27,7 @@ import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; import { IPreimageOracle } from "interfaces/dispute/IBigStepper.sol"; import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol"; import { IFaultDisputeGame } from "interfaces/dispute/IFaultDisputeGame.sol"; +import { ISuperFaultDisputeGame } from "interfaces/dispute/ISuperFaultDisputeGame.sol"; import { IDelayedWETH } from "interfaces/dispute/IDelayedWETH.sol"; contract SuperFaultDisputeGame_Init is DisputeGameFactory_Init { @@ -34,9 +35,9 @@ contract SuperFaultDisputeGame_Init is DisputeGameFactory_Init { GameType internal constant GAME_TYPE = GameType.wrap(4); /// @dev The implementation of the game. - IFaultDisputeGame internal gameImpl; + ISuperFaultDisputeGame internal gameImpl; /// @dev The `Clone` proxy of the game. - IFaultDisputeGame internal gameProxy; + ISuperFaultDisputeGame internal gameProxy; /// @dev The extra data passed to the game for initialization. bytes internal extraData; @@ -46,14 +47,14 @@ contract SuperFaultDisputeGame_Init is DisputeGameFactory_Init { event ReceiveETH(uint256 amount); - function init(Claim rootClaim, Claim absolutePrestate, uint256 l2BlockNumber) public { + function init(Claim rootClaim, Claim absolutePrestate, uint256 l2SequenceNumber) public { // Set the time to a realistic date. if (!isForkTest()) { vm.warp(1690906994); } // Set the extra data for the game creation - extraData = abi.encode(l2BlockNumber); + extraData = abi.encode(l2SequenceNumber); // Set preimage oracle challenge period to something arbitrary (4 seconds) just so we can // actually test the clock extensions later on. This is not a realistic value. @@ -68,14 +69,14 @@ contract SuperFaultDisputeGame_Init is DisputeGameFactory_Init { ); // Deploy an implementation of the fault game - gameImpl = IFaultDisputeGame( + gameImpl = ISuperFaultDisputeGame( DeployUtils.create1({ _name: "SuperFaultDisputeGame", _args: DeployUtils.encodeConstructor( abi.encodeCall( - IFaultDisputeGame.__constructor__, + ISuperFaultDisputeGame.__constructor__, ( - IFaultDisputeGame.GameConstructorParams({ + ISuperFaultDisputeGame.GameConstructorParams({ gameType: GAME_TYPE, absolutePrestate: absolutePrestate, maxGameDepth: 2 ** 3, @@ -106,7 +107,7 @@ contract SuperFaultDisputeGame_Init is DisputeGameFactory_Init { } // Create a new game. - gameProxy = IFaultDisputeGame( + gameProxy = ISuperFaultDisputeGame( payable(address(disputeGameFactory.create{ value: bondAmount }(GAME_TYPE, rootClaim, extraData))) ); @@ -140,8 +141,8 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { bytes internal absolutePrestateData; /// @dev The absolute prestate of the trace. Claim internal absolutePrestate; - /// @dev A valid l2BlockNumber that comes after the current anchor root block. - uint256 validL2BlockNumber; + /// @dev A valid l2SequenceNumber that comes after the current anchor root block. + uint256 validl2SequenceNumber; function setUp() public override { absolutePrestateData = abi.encode(0); @@ -151,17 +152,17 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { // Get the actual anchor roots (Hash root, uint256 l2Bn) = anchorStateRegistry.getAnchorRoot(); - validL2BlockNumber = l2Bn + 1; + validl2SequenceNumber = l2Bn + 1; ROOT_CLAIM = Claim.wrap(Hash.unwrap(root)); if (isForkTest()) { - // Set the init bond of anchor game type 0 to be 0. + // Set the init bond of anchor game type 4 to be 0. vm.store( - address(disputeGameFactory), keccak256(abi.encode(GameType.wrap(0), uint256(102))), bytes32(uint256(0)) + address(disputeGameFactory), keccak256(abi.encode(GameType.wrap(4), uint256(102))), bytes32(uint256(0)) ); } - super.init({ rootClaim: ROOT_CLAIM, absolutePrestate: absolutePrestate, l2BlockNumber: validL2BlockNumber }); + super.init({ rootClaim: ROOT_CLAIM, absolutePrestate: absolutePrestate, l2SequenceNumber: validl2SequenceNumber }); } //////////////////////////////////////////////////////////////// @@ -185,9 +186,9 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { _name: "SuperFaultDisputeGame", _args: DeployUtils.encodeConstructor( abi.encodeCall( - IFaultDisputeGame.__constructor__, + ISuperFaultDisputeGame.__constructor__, ( - IFaultDisputeGame.GameConstructorParams({ + ISuperFaultDisputeGame.GameConstructorParams({ gameType: GAME_TYPE, absolutePrestate: absolutePrestate, maxGameDepth: _maxGameDepth, @@ -229,9 +230,9 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { _name: "SuperFaultDisputeGame", _args: DeployUtils.encodeConstructor( abi.encodeCall( - IFaultDisputeGame.__constructor__, + ISuperFaultDisputeGame.__constructor__, ( - IFaultDisputeGame.GameConstructorParams({ + ISuperFaultDisputeGame.GameConstructorParams({ gameType: GAME_TYPE, absolutePrestate: absolutePrestate, maxGameDepth: 2 ** 3, @@ -269,9 +270,9 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { _name: "SuperFaultDisputeGame", _args: DeployUtils.encodeConstructor( abi.encodeCall( - IFaultDisputeGame.__constructor__, + ISuperFaultDisputeGame.__constructor__, ( - IFaultDisputeGame.GameConstructorParams({ + ISuperFaultDisputeGame.GameConstructorParams({ gameType: GAME_TYPE, absolutePrestate: absolutePrestate, maxGameDepth: maxGameDepth, @@ -309,9 +310,9 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { _name: "SuperFaultDisputeGame", _args: DeployUtils.encodeConstructor( abi.encodeCall( - IFaultDisputeGame.__constructor__, + ISuperFaultDisputeGame.__constructor__, ( - IFaultDisputeGame.GameConstructorParams({ + ISuperFaultDisputeGame.GameConstructorParams({ gameType: GAME_TYPE, absolutePrestate: absolutePrestate, maxGameDepth: 2 ** 3, @@ -357,9 +358,9 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { _name: "SuperFaultDisputeGame", _args: DeployUtils.encodeConstructor( abi.encodeCall( - IFaultDisputeGame.__constructor__, + ISuperFaultDisputeGame.__constructor__, ( - IFaultDisputeGame.GameConstructorParams({ + ISuperFaultDisputeGame.GameConstructorParams({ gameType: GAME_TYPE, absolutePrestate: absolutePrestate, maxGameDepth: 16, @@ -395,9 +396,9 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { _name: "SuperFaultDisputeGame", _args: DeployUtils.encodeConstructor( abi.encodeCall( - IFaultDisputeGame.__constructor__, + ISuperFaultDisputeGame.__constructor__, ( - IFaultDisputeGame.GameConstructorParams({ + ISuperFaultDisputeGame.GameConstructorParams({ gameType: GameType.wrap(type(uint32).max), absolutePrestate: absolutePrestate, maxGameDepth: 16, @@ -450,19 +451,20 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { } //////////////////////////////////////////////////////////////// - // `IFaultDisputeGame` Implementation Tests // + // `ISuperFaultDisputeGame` Implementation Tests // //////////////////////////////////////////////////////////////// /// @dev Tests that the game cannot be initialized with an output root that commits to <= the configured starting /// block number function testFuzz_initialize_cannotProposeGenesis_reverts(uint256 _blockNumber) public { - (, uint256 startingL2Block) = gameProxy.startingOutputRoot(); + (, uint256 startingL2Block) = gameProxy.startingProposal(); _blockNumber = bound(_blockNumber, 0, startingL2Block); Claim claim = _dummyClaim(); vm.expectRevert(abi.encodeWithSelector(UnexpectedRootClaim.selector, claim)); - gameProxy = - IFaultDisputeGame(payable(address(disputeGameFactory.create(GAME_TYPE, claim, abi.encode(_blockNumber))))); + gameProxy = ISuperFaultDisputeGame( + payable(address(disputeGameFactory.create(GAME_TYPE, claim, abi.encode(_blockNumber)))) + ); } /// @dev Tests that the proxy receives ETH from the dispute game factory. @@ -471,11 +473,11 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { vm.deal(address(this), _value); assertEq(address(gameProxy).balance, 0); - gameProxy = IFaultDisputeGame( + gameProxy = ISuperFaultDisputeGame( payable( address( disputeGameFactory.create{ value: _value }( - GAME_TYPE, arbitaryRootClaim, abi.encode(validL2BlockNumber) + GAME_TYPE, arbitaryRootClaim, abi.encode(validl2SequenceNumber) ) ) ) @@ -488,7 +490,7 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { function test_initialize_invalidRoot_reverts() public { Claim claim = Claim.wrap(keccak256("invalid")); vm.expectRevert(bytes4(keccak256("SuperFaultDisputeGameInvalidRootClaim()"))); - gameProxy = IFaultDisputeGame(payable(address(disputeGameFactory.create(GAME_TYPE, claim, extraData)))); + gameProxy = ISuperFaultDisputeGame(payable(address(disputeGameFactory.create(GAME_TYPE, claim, extraData)))); } /// @dev Tests that the game cannot be initialized with extra data of the incorrect length (must be 32 bytes) @@ -505,14 +507,14 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { bytes memory _extraData = new bytes(_extraDataLen); // Assign the first 32 bytes in `extraData` to a valid L2 block number passed the starting block. - (, uint256 startingL2Block) = gameProxy.startingOutputRoot(); + (, uint256 startingL2Block) = gameProxy.startingProposal(); assembly { mstore(add(_extraData, 0x20), add(startingL2Block, 1)) } Claim claim = _dummyClaim(); vm.expectRevert(abi.encodeWithSelector(BadExtraData.selector)); - gameProxy = IFaultDisputeGame(payable(address(disputeGameFactory.create(GAME_TYPE, claim, _extraData)))); + gameProxy = ISuperFaultDisputeGame(payable(address(disputeGameFactory.create(GAME_TYPE, claim, _extraData)))); } /// @dev Tests that the game is initialized with the correct data. @@ -553,7 +555,7 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { // Creation should fail. vm.expectRevert(AnchorRootNotFound.selector); - gameProxy = IFaultDisputeGame(payable(address(disputeGameFactory.create(GAME_TYPE, _dummyClaim(), hex"")))); + gameProxy = ISuperFaultDisputeGame(payable(address(disputeGameFactory.create(GAME_TYPE, _dummyClaim(), hex"")))); } /// @dev Tests that the game cannot be initialized twice. @@ -562,13 +564,13 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { gameProxy.initialize(); } - /// @dev Tests that startingOutputRoot and it's getters are set correctly. - function test_startingOutputRootGetters_succeeds() public view { - (Hash root, uint256 l2BlockNumber) = gameProxy.startingOutputRoot(); + /// @dev Tests that startingProposal and it's getters are set correctly. + function test_startingProposalGetters_succeeds() public view { + (Hash root, uint256 l2SequenceNumber) = gameProxy.startingProposal(); (Hash anchorRoot, uint256 anchorRootBlockNumber) = anchorStateRegistry.anchors(GAME_TYPE); - assertEq(gameProxy.startingBlockNumber(), l2BlockNumber); - assertEq(gameProxy.startingBlockNumber(), anchorRootBlockNumber); + assertEq(gameProxy.startingSequenceNumber(), l2SequenceNumber); + assertEq(gameProxy.startingSequenceNumber(), anchorRootBlockNumber); assertEq(Hash.unwrap(gameProxy.startingRootHash()), Hash.unwrap(root)); assertEq(Hash.unwrap(gameProxy.startingRootHash()), Hash.unwrap(anchorRoot)); } @@ -1666,8 +1668,8 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { /// favor of the defender and the anchor state is older than the game state. function test_resolve_validNewerStateUpdatesAnchor_succeeds() public { // Confirm that the anchor state is older than the game state. - (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assert(l2BlockNumber < gameProxy.l2BlockNumber()); + (Hash root, uint256 l2SequenceNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); + assert(l2SequenceNumber < gameProxy.l2SequenceNumber()); // Resolve the game. vm.warp(block.timestamp + 3 days + 12 hours); @@ -1681,8 +1683,8 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { gameProxy.closeGame(); // Confirm that the anchor state is now the same as the game state. - (root, l2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assertEq(l2BlockNumber, gameProxy.l2BlockNumber()); + (root, l2SequenceNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); + assertEq(l2SequenceNumber, gameProxy.l2SequenceNumber()); assertEq(root.raw(), gameProxy.rootClaim().raw()); } @@ -1690,14 +1692,14 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { /// resolves in favor of the defender but the game state is not newer than the anchor state. function test_resolve_validOlderStateSameAnchor_succeeds() public { // Mock the game block to be older than the game state. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2BlockNumber, ()), abi.encode(0)); + vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(0)); // Confirm that the anchor state is newer than the game state. - (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assert(l2BlockNumber >= gameProxy.l2BlockNumber()); + (Hash root, uint256 l2SequenceNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); + assert(l2SequenceNumber >= gameProxy.l2SequenceNumber()); // Resolve the game. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2BlockNumber, ()), abi.encode(0)); + vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(0)); vm.warp(block.timestamp + 3 days + 12 hours); gameProxy.resolveClaim(0, 0); assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.DEFENDER_WINS)); @@ -1709,8 +1711,8 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { gameProxy.closeGame(); // Confirm that the anchor state is the same as the initial anchor state. - (Hash updatedRoot, uint256 updatedL2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assertEq(updatedL2BlockNumber, l2BlockNumber); + (Hash updatedRoot, uint256 updatedl2SequenceNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); + assertEq(updatedl2SequenceNumber, l2SequenceNumber); assertEq(updatedRoot.raw(), root.raw()); } @@ -1718,8 +1720,8 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { /// resolves in favor of the challenger, even if the game state is newer than the anchor. function test_resolve_invalidStateSameAnchor_succeeds() public { // Confirm that the anchor state is older than the game state. - (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assert(l2BlockNumber < gameProxy.l2BlockNumber()); + (Hash root, uint256 l2SequenceNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); + assert(l2SequenceNumber < gameProxy.l2SequenceNumber()); // Challenge the claim and resolve it. (,,,, Claim disputed,,) = gameProxy.claimData(0); @@ -1736,8 +1738,8 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { gameProxy.closeGame(); // Confirm that the anchor state is the same as the initial anchor state. - (Hash updatedRoot, uint256 updatedL2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assertEq(updatedL2BlockNumber, l2BlockNumber); + (Hash updatedRoot, uint256 updatedl2SequenceNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); + assertEq(updatedl2SequenceNumber, l2SequenceNumber); assertEq(updatedRoot.raw(), root.raw()); } @@ -1977,7 +1979,7 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { gameProxy.attack{ value: lastBond }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); // Expected start/disputed claims - (Hash root,) = gameProxy.startingOutputRoot(); + (Hash root,) = gameProxy.startingProposal(); bytes32 startingClaim = root.raw(); bytes32 disputedClaim = bytes32(uint256(3)); Position disputedPos = LibPosition.wrap(4, 0); @@ -1987,7 +1989,7 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { gameProxy.l1Head().raw(), startingClaim, disputedClaim, - bytes32(uint256(gameProxy.l2BlockNumber()) << 0xC0) + bytes32(uint256(gameProxy.l2SequenceNumber()) << 0xC0) ]; for (uint256 i = 1; i <= 4; i++) { @@ -2037,7 +2039,7 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { gameProxy.l1Head().raw(), startingClaim, disputedClaim, - bytes32(uint256(gameProxy.l2BlockNumber()) << 0xC0) + bytes32(uint256(gameProxy.l2SequenceNumber()) << 0xC0) ]; for (uint256 i = 1; i <= 4; i++) { @@ -2063,13 +2065,13 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { /// @dev Tests that the L2 block number claim is favored over the bisected-to block when adding data /// - function test_addLocalData_l2BlockNumberExtension_succeeds() public { + function test_addLocalData_l2SequenceNumberExtension_succeeds() public { // Deploy a new dispute game with a L2 block number claim of 8. This is directly in the middle of // the leaves in our output bisection test tree, at SPLIT_DEPTH = 2 ** 2 - IFaultDisputeGame game = IFaultDisputeGame( + ISuperFaultDisputeGame game = ISuperFaultDisputeGame( address( disputeGameFactory.create( - GAME_TYPE, Claim.wrap(bytes32(uint256(0xFF))), abi.encode(uint256(validL2BlockNumber)) + GAME_TYPE, Claim.wrap(bytes32(uint256(0xFF))), abi.encode(uint256(validl2SequenceNumber)) ) ) ); @@ -2105,9 +2107,9 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { bytes32 disputedClaim = bytes32(uint256(0xFF)); Position disputedPos = LibPosition.wrap(0, 0); - // Expected local data. This should be `l2BlockNumber`, and not the actual bisected-to block, + // Expected local data. This should be `l2SequenceNumber`, and not the actual bisected-to block, // as we choose the minimum between the two. - bytes32 expectedNumber = bytes32(uint256(validL2BlockNumber << 0xC0)); + bytes32 expectedNumber = bytes32(uint256(validl2SequenceNumber << 0xC0)); uint256 expectedLen = 8; uint256 l2NumberIdent = LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER; @@ -2319,7 +2321,7 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { function _generateOutputRootProof( bytes32 _storageRoot, bytes32 _withdrawalRoot, - bytes memory _l2BlockNumber + bytes memory _l2SequenceNumber ) internal pure @@ -2335,7 +2337,7 @@ contract SuperFaultDisputeGame_Test is SuperFaultDisputeGame_Init { rawHeaderRLP[5] = hex"83FACADE"; rawHeaderRLP[6] = hex"83FACADE"; rawHeaderRLP[7] = hex"83FACADE"; - rawHeaderRLP[8] = RLPWriter.writeBytes(_l2BlockNumber); + rawHeaderRLP[8] = RLPWriter.writeBytes(_l2SequenceNumber); rlp_ = RLPWriter.writeList(rawHeaderRLP); // Output root @@ -2733,7 +2735,7 @@ contract SuperFaultDispute_1v1_Actors_Test is SuperFaultDisputeGame_Init { Claim absolutePrestateExec = _changeClaimStatus(Claim.wrap(keccak256(absolutePrestateData_)), VMStatuses.UNFINISHED); Claim rootClaim = Claim.wrap(bytes32(uint256(_rootClaim))); - super.init({ rootClaim: rootClaim, absolutePrestate: absolutePrestateExec, l2BlockNumber: _rootClaim }); + super.init({ rootClaim: rootClaim, absolutePrestate: absolutePrestateExec, l2SequenceNumber: _rootClaim }); } /// @dev Helper to create actors for the 1v1 dispute. @@ -2748,13 +2750,13 @@ contract SuperFaultDispute_1v1_Actors_Test is SuperFaultDisputeGame_Init { internal { honest = new HonestDisputeActor({ - _gameProxy: gameProxy, + _gameProxy: IFaultDisputeGame(address(gameProxy)), _l2Outputs: _honestL2Outputs, _trace: _honestTrace, _preStateData: _honestPreStateData }); dishonest = new HonestDisputeActor({ - _gameProxy: gameProxy, + _gameProxy: IFaultDisputeGame(address(gameProxy)), _l2Outputs: _dishonestL2Outputs, _trace: _dishonestTrace, _preStateData: _dishonestPreStateData @@ -2799,10 +2801,10 @@ contract SuperFaultDispute_1v1_Actors_Test is SuperFaultDisputeGame_Init { contract ClaimCreditReenter { Vm internal immutable vm; - IFaultDisputeGame internal immutable GAME; + ISuperFaultDisputeGame internal immutable GAME; uint256 public numCalls; - constructor(IFaultDisputeGame _gameProxy, Vm _vm) { + constructor(ISuperFaultDisputeGame _gameProxy, Vm _vm) { GAME = _gameProxy; vm = _vm; } diff --git a/packages/contracts-bedrock/test/invariants/SuperFaultDisputeGame.t.sol b/packages/contracts-bedrock/test/invariants/SuperFaultDisputeGame.t.sol index 0b85caa0846..cfd40b35bfc 100644 --- a/packages/contracts-bedrock/test/invariants/SuperFaultDisputeGame.t.sol +++ b/packages/contracts-bedrock/test/invariants/SuperFaultDisputeGame.t.sol @@ -3,6 +3,7 @@ pragma solidity 0.8.15; // Testing import { SuperFaultDisputeGame_Init } from "test/dispute/SuperFaultDisputeGame.t.sol"; +import { IFaultDisputeGame } from "interfaces/dispute/IFaultDisputeGame.sol"; import { RandomClaimActor } from "test/invariants/FaultDisputeGame.t.sol"; // Libraries @@ -18,9 +19,9 @@ contract SuperFaultDisputeGame_Solvency_Invariant is SuperFaultDisputeGame_Init function setUp() public override { super.setUp(); - super.init({ rootClaim: ROOT_CLAIM, absolutePrestate: ABSOLUTE_PRESTATE, l2BlockNumber: 0x10 }); + super.init({ rootClaim: ROOT_CLAIM, absolutePrestate: ABSOLUTE_PRESTATE, l2SequenceNumber: 0x10 }); - actor = new RandomClaimActor(gameProxy, vm); + actor = new RandomClaimActor(IFaultDisputeGame(address(gameProxy)), vm); targetContract(address(actor)); vm.startPrank(address(actor)); diff --git a/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol b/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol index 73959dbb0e5..26c3d3df69a 100644 --- a/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol +++ b/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol @@ -26,7 +26,7 @@ import { IProtocolVersions, ProtocolVersion } from "interfaces/L1/IProtocolVersi import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; import { IProxy } from "interfaces/universal/IProxy.sol"; -import { Claim, Duration, GameType, GameTypes, Hash, OutputRoot } from "src/dispute/lib/Types.sol"; +import { Claim, Duration, GameType, GameTypes, Hash, Proposal } from "src/dispute/lib/Types.sol"; contract DeployOPChainInput_Test is Test { DeployOPChainInput doi; @@ -327,7 +327,7 @@ contract DeployOPChain_TestBase is Test { uint32 basefeeScalar = 100; uint32 blobBaseFeeScalar = 200; uint256 l2ChainId = 300; - OutputRoot startingAnchorRoot = OutputRoot({ root: Hash.wrap(keccak256("defaultOutputRoot")), l2BlockNumber: 400 }); + Proposal startingAnchorRoot = Proposal({ root: Hash.wrap(keccak256("defaultOutputRoot")), l2SequenceNumber: 400 }); IOPContractsManager opcm = IOPContractsManager(address(0)); string saltMixer = "defaultSaltMixer"; uint64 gasLimit = 60_000_000; diff --git a/packages/contracts-bedrock/test/opcm/SetDisputeGameImpl.t.sol b/packages/contracts-bedrock/test/opcm/SetDisputeGameImpl.t.sol index 1ece4e242bb..c5ef3011a9f 100644 --- a/packages/contracts-bedrock/test/opcm/SetDisputeGameImpl.t.sol +++ b/packages/contracts-bedrock/test/opcm/SetDisputeGameImpl.t.sol @@ -4,7 +4,7 @@ pragma solidity ^0.8.0; import { Test } from "forge-std/Test.sol"; import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; import { IDisputeGameFactory } from "interfaces/dispute/IDisputeGameFactory.sol"; -import { GameType, OutputRoot, Hash } from "src/dispute/lib/Types.sol"; +import { GameType, Proposal, Hash } from "src/dispute/lib/Types.sol"; import { SetDisputeGameImpl, SetDisputeGameImplInput } from "scripts/deploy/SetDisputeGameImpl.s.sol"; import { DisputeGameFactory } from "src/dispute/DisputeGameFactory.sol"; import { Proxy } from "src/universal/Proxy.sol"; @@ -100,7 +100,7 @@ contract SetDisputeGameImpl_Test is Test { ( ISuperchainConfig(address(supConfigProxy)), factory, - OutputRoot({ root: Hash.wrap(0), l2BlockNumber: 0 }), + Proposal({ root: Hash.wrap(0), l2SequenceNumber: 0 }), GameType.wrap(100) ) ) diff --git a/packages/contracts-bedrock/test/universal/Specs.t.sol b/packages/contracts-bedrock/test/universal/Specs.t.sol index 6076574e72e..421c4a4f071 100644 --- a/packages/contracts-bedrock/test/universal/Specs.t.sol +++ b/packages/contracts-bedrock/test/universal/Specs.t.sol @@ -519,6 +519,7 @@ contract Specification_Test is CommonTest { _addSpec({ _name: "PermissionedDisputeGame", _sel: _getSel("initialize()") }); _addSpec({ _name: "PermissionedDisputeGame", _sel: _getSel("l1Head()") }); _addSpec({ _name: "PermissionedDisputeGame", _sel: _getSel("l2BlockNumber()") }); + _addSpec({ _name: "PermissionedDisputeGame", _sel: _getSel("l2SequenceNumber()") }); _addSpec({ _name: "PermissionedDisputeGame", _sel: _getSel("l2BlockNumberChallenged()") }); _addSpec({ _name: "PermissionedDisputeGame", _sel: _getSel("l2BlockNumberChallenger()") }); _addSpec({ _name: "PermissionedDisputeGame", _sel: _getSel("l2ChainId()") }); @@ -583,6 +584,7 @@ contract Specification_Test is CommonTest { _addSpec({ _name: "FaultDisputeGame", _sel: _getSel("initialize()") }); _addSpec({ _name: "FaultDisputeGame", _sel: _getSel("l1Head()") }); _addSpec({ _name: "FaultDisputeGame", _sel: _getSel("l2BlockNumber()") }); + _addSpec({ _name: "FaultDisputeGame", _sel: _getSel("l2SequenceNumber()") }); _addSpec({ _name: "FaultDisputeGame", _sel: _getSel("l2BlockNumberChallenged()") }); _addSpec({ _name: "FaultDisputeGame", _sel: _getSel("l2BlockNumberChallenger()") }); _addSpec({ _name: "FaultDisputeGame", _sel: _getSel("l2ChainId()") }); @@ -634,7 +636,7 @@ contract Specification_Test is CommonTest { _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("hasUnlockedCredit(address)") }); _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("initialize()") }); _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("l1Head()") }); - _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("l2BlockNumber()") }); + _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("l2SequenceNumber()") }); _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("maxClockDuration()") }); _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("maxGameDepth()") }); _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("move(bytes32,uint256,bytes32,bool)") }); @@ -648,8 +650,8 @@ contract Specification_Test is CommonTest { _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("resolvedSubgames(uint256)") }); _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("rootClaim()") }); _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("splitDepth()") }); - _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("startingBlockNumber()") }); - _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("startingOutputRoot()") }); + _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("startingSequenceNumber()") }); + _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("startingProposal()") }); _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("startingRootHash()") }); _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("status()") }); _addSpec({ _name: "SuperFaultDisputeGame", _sel: _getSel("step(uint256,bool,bytes,bytes)") }); @@ -693,7 +695,6 @@ contract Specification_Test is CommonTest { _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("hasUnlockedCredit(address)") }); _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("initialize()") }); _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("l1Head()") }); - _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("l2BlockNumber()") }); _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("maxClockDuration()") }); _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("maxGameDepth()") }); _addSpec({ @@ -711,8 +712,9 @@ contract Specification_Test is CommonTest { _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("resolvedSubgames(uint256)") }); _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("rootClaim()") }); _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("splitDepth()") }); - _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("startingBlockNumber()") }); - _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("startingOutputRoot()") }); + _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("l2SequenceNumber()") }); + _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("startingSequenceNumber()") }); + _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("startingProposal()") }); _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("startingRootHash()") }); _addSpec({ _name: "SuperPermissionedDisputeGame", _sel: _getSel("status()") }); _addSpec({ diff --git a/packages/contracts-bedrock/test/vendor/Initializable.t.sol b/packages/contracts-bedrock/test/vendor/Initializable.t.sol index 34c84e675e1..22d919c3c2c 100644 --- a/packages/contracts-bedrock/test/vendor/Initializable.t.sol +++ b/packages/contracts-bedrock/test/vendor/Initializable.t.sol @@ -10,7 +10,7 @@ import { Process } from "scripts/libraries/Process.sol"; // Libraries import { LibString } from "@solady/utils/LibString.sol"; -import { GameType, Hash, OutputRoot } from "src/dispute/lib/Types.sol"; +import { GameType, Hash, Proposal } from "src/dispute/lib/Types.sol"; import { EIP1967Helper } from "test/mocks/EIP1967Helper.sol"; // Interfaces @@ -303,7 +303,7 @@ contract Initializer_Test is CommonTest { ( ISuperchainConfig(address(0)), IDisputeGameFactory(address(0)), - OutputRoot({ root: Hash.wrap(bytes32(0)), l2BlockNumber: 0 }), + Proposal({ root: Hash.wrap(bytes32(0)), l2SequenceNumber: 0 }), GameType.wrap(uint32(deploy.cfg().respectedGameType())) ) ) @@ -319,7 +319,7 @@ contract Initializer_Test is CommonTest { ( ISuperchainConfig(address(0)), IDisputeGameFactory(address(0)), - OutputRoot({ root: Hash.wrap(bytes32(0)), l2BlockNumber: 0 }), + Proposal({ root: Hash.wrap(bytes32(0)), l2SequenceNumber: 0 }), GameType.wrap(uint32(deploy.cfg().respectedGameType())) ) )