Merge branch 'develop' into refcell/challenger/flags

op-program/verify/cmd/goerli.go

@@ -127,7 +127,7 @@ func Run(l1RpcUrl string, l2RpcUrl string, l2OracleAddr common.Address) error {
 }
 
 func runFaultProofProgram(ctx context.Context, args []string) error {
-	ctx, cancel := context.WithTimeout(ctx, 30*time.Minute)
+	ctx, cancel := context.WithTimeout(ctx, 60*time.Minute)
 	defer cancel()
 	cmd := exec.CommandContext(ctx, "./bin/op-program", args...)
 	cmd.Stdout = os.Stdout

op-proposer/proposer/l2_output_submitter.go

@@ -22,6 +22,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
+	"github.com/ethereum-optimism/optimism/op-proposer/flags"
 	"github.com/ethereum-optimism/optimism/op-proposer/metrics"
 	opservice "github.com/ethereum-optimism/optimism/op-service"
 	opclient "github.com/ethereum-optimism/optimism/op-service/client"
@@ -36,6 +37,9 @@ var supportedL2OutputVersion = eth.Bytes32{}
 // Main is the entrypoint into the L2 Output Submitter. This method executes the
 // service and blocks until the service exits.
 func Main(version string, cliCtx *cli.Context) error {
+	if err := flags.CheckRequired(cliCtx); err != nil {
+		return err
+	}
 	cfg := NewConfig(cliCtx)
 	if err := cfg.Check(); err != nil {
 		return fmt.Errorf("invalid CLI flags: %w", err)

packages/contracts-bedrock/contracts/dispute/IAttestationDisputeGame.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import { IDisputeGame } from "./IDisputeGame.sol";
+
+/**
+ * @title IAttestationDisputeGame
+ * @notice The interface for an attestation-based DisputeGame meant to contest output
+ *         proposals in Optimism's `L2OutputOracle` contract.
+ */
+interface IAttestationDisputeGame is IDisputeGame {
+    /**
+     * @notice A mapping of addresses from the `signerSet` to booleans signifying whether
+     *         or not they have authorized the `rootClaim` to be invalidated.
+     * @param challenger The address to check for authorization.
+     * @return _challenged Whether or not the `challenger` has challenged the `rootClaim`.
+     */
+    function challenges(address challenger) external view returns (bool _challenged);
+
+    /**
+     * @notice The signer set consists of authorized public keys that may challenge
+     *         the `rootClaim`.
+     * @param addr The address to check for authorization.
+     * @return _isAuthorized Whether or not the `addr` is part of the signer set.
+     */
+    function signerSet(address addr) external view returns (bool _isAuthorized);
+
+    /**
+     * @notice The amount of signatures required to successfully challenge the `rootClaim`
+     *         output proposal. Once this threshold is met by members of the `signerSet`
+     *         calling `challenge`, the game will be resolved to `CHALLENGER_WINS`.
+     * @custom:invariant The `signatureThreshold` may never be greater than the length
+     *                   of the `signerSet`.
+     * @return _signatureThreshold The amount of signatures required to successfully
+     *         challenge the `rootClaim` output proposal.
+     */
+    function frozenSignatureThreshold() external view returns (uint256 _signatureThreshold);
+
+    /**
+     * @notice Returns the L2 Block Number that the `rootClaim` commits to.
+     *         Exists within the `extraData`.
+     * @return _l2BlockNumber The L2 Block Number that the `rootClaim` commits to.
+     */
+    function l2BlockNumber() external view returns (uint256 _l2BlockNumber);
+
+    /**
+     * @notice Challenge the `rootClaim`.
+     * @dev - If the `ecrecover`ed address that created the signature is not a part of
+     *        the signer set returned by `signerSet`, this function should revert.
+     *      - If the `ecrecover`ed address that created the signature is not the
+     *        msg.sender, this function should revert.
+     *      - If the signature provided is the signature that breaches the signature
+     *        threshold, the function should call the `resolve` function to resolve
+     *        the game as `CHALLENGER_WINS`.
+     *      - When the game resolves, the bond attached to the root claim should be
+     *        distributed among the signers who participated in challenging the
+     *        invalid claim.
+     * @param signature An EIP-712 signature committing to the `rootClaim` and
+     *        `l2BlockNumber` (within the `extraData`) from a key that exists
+     *         within the `signerSet`.
+     */
+    function challenge(bytes calldata signature) external;
+}

packages/contracts-bedrock/contracts/dispute/IBondManager.sol

+/// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+/**
+ * @title IBondManager
+ * @notice The Bond Manager holds ether posted as a bond for a bond id.
+ */
+interface IBondManager {
+    /**
+     * @notice Post a bond with a given id and owner.
+     * @dev This function will revert if the provided bondId is already in use.
+     * @param bondId is the id of the bond.
+     * @param owner is the address that owns the bond.
+     * @param minClaimHold is the minimum amount of time the owner
+     *        must wait before reclaiming their bond.
+     */
+    function post(
+        bytes32 bondId,
+        address owner,
+        uint256 minClaimHold
+    ) external payable;
+
+    /**
+     * @notice Seizes the bond with the given id.
+     * @dev This function will revert if there is no bond at the given id.
+     * @param bondId is the id of the bond.
+     */
+    function seize(bytes32 bondId) external;
+
+    /**
+     * @notice Seizes the bond with the given id and distributes it to recipients.
+     * @dev This function will revert if there is no bond at the given id.
+     * @param bondId is the id of the bond.
+     * @param recipients is a set of addresses to split the bond amongst.
+     */
+    function seizeAndSplit(bytes32 bondId, address[] calldata recipients) external;
+
+    /**
+     * @notice Reclaims the bond of the bond owner.
+     * @dev This function will revert if there is no bond at the given id.
+     * @param bondId is the id of the bond.
+     */
+    function reclaim(bytes32 bondId) external;
+}

packages/contracts-bedrock/contracts/dispute/IDisputeGame.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import { Claim, GameType, GameStatus, Timestamp } from "../libraries/DisputeTypes.sol";
+
+import { IVersioned } from "./IVersioned.sol";
+import { IBondManager } from "./IBondManager.sol";
+import { IInitializable } from "./IInitializable.sol";
+
+/**
+ * @title IDisputeGame
+ * @notice The generic interface for a DisputeGame contract.
+ */
+interface IDisputeGame is IInitializable, IVersioned {
+    /**
+     * @notice Emitted when the game is resolved.
+     * @param status The status of the game after resolution.
+     */
+    event Resolved(GameStatus indexed status);
+
+    /// @notice Returns the timestamp that the DisputeGame contract was created at.
+
+    /**
+     * @notice Returns the timestamp that the DisputeGame contract was created at.
+     * @return _createdAt The timestamp that the DisputeGame contract was created at.
+     */
+    function createdAt() external view returns (Timestamp _createdAt);
+
+    /**
+     * @notice Returns the current status of the game.
+     * @return _status The current status of the game.
+     */
+    function status() external view returns (GameStatus _status);
+
+    /**
+     * @notice Getter for the game type.
+     * @dev `clones-with-immutable-args` argument #1
+     * @dev The reference impl should be entirely different depending on the type (fault, validity)
+     *      i.e. The game type should indicate the security model.
+     * @return _gameType The type of proof system being used.
+     */
+    function gameType() external view returns (GameType _gameType);
+
+    /**
+     * @notice Getter for the root claim.
+     * @dev `clones-with-immutable-args` argument #2
+     * @return _rootClaim The root claim of the DisputeGame.
+     */
+    function rootClaim() external view returns (Claim _rootClaim);
+
+    /**
+     * @notice Getter for the extra data.
+     * @dev `clones-with-immutable-args` argument #3
+     * @return _extraData Any extra data supplied to the dispute game contract by the creator.
+     */
+    function extraData() external view returns (bytes memory _extraData);
+
+    /**
+     * @notice Returns the address of the `BondManager` used.
+     * @return _bondManager The address of the `BondManager` used.
+     */
+    function bondManager() external view returns (IBondManager _bondManager);
+
+    /**
+     * @notice If all necessary information has been gathered, this function should mark the game
+     *         status as either `CHALLENGER_WINS` or `DEFENDER_WINS` and return the status of
+     *         the resolved game. It is at this stage that the bonds should be awarded to the
+     *         necessary parties.
+     * @dev May only be called if the `status` is `IN_PROGRESS`.
+     * @return _status The status of the game after resolution.
+     */
+    function resolve() external returns (GameStatus _status);
+}

packages/contracts-bedrock/contracts/dispute/IDisputeGameFactory.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import { Claim, GameType } from "../libraries/DisputeTypes.sol";
+
+import { IDisputeGame } from "./IDisputeGame.sol";
+import { IOwnable } from "./IOwnable.sol";
+
+/**
+ * @title IDisputeGameFactory
+ * @notice The interface for a DisputeGameFactory contract.
+ */
+interface IDisputeGameFactory is IOwnable {
+    /**
+     * @notice Emitted when a new dispute game is created
+     * @param disputeProxy The address of the dispute game proxy
+     * @param gameType The type of the dispute game proxy's implementation
+     * @param rootClaim The root claim of the dispute game
+     */
+    event DisputeGameCreated(
+        address indexed disputeProxy,
+        GameType indexed gameType,
+        Claim indexed rootClaim
+    );
+
+    /**
+     * @notice `games` queries an internal a mapping that maps the hash of
+     *         `gameType ++ rootClaim ++ extraData` to the deployed `DisputeGame` clone.
+     * @dev `++` equates to concatenation.
+     * @param gameType The type of the DisputeGame - used to decide the proxy implementation
+     * @param rootClaim The root claim of the DisputeGame.
+     * @param extraData Any extra data that should be provided to the created dispute game.
+     * @return _proxy The clone of the `DisputeGame` created with the given parameters.
+     *         Returns `address(0)` if nonexistent.
+     */
+    function games(
+        GameType gameType,
+        Claim rootClaim,
+        bytes calldata extraData
+    ) external view returns (IDisputeGame _proxy);
+
+    /**
+     * @notice `gameImpls` is a mapping that maps `GameType`s to their respective
+     *         `IDisputeGame` implementations.
+     * @param gameType The type of the dispute game.
+     * @return _impl The address of the implementation of the game type.
+     *         Will be cloned on creation of a new dispute game with the given `gameType`.
+     */
+    function gameImpls(GameType gameType) external view returns (IDisputeGame _impl);
+
+    /**
+     * @notice Creates a new DisputeGame proxy contract.
+     * @param gameType The type of the DisputeGame - used to decide the proxy implementation
+     * @param rootClaim The root claim of the DisputeGame.
+     * @param extraData Any extra data that should be provided to the created dispute game.
+     * @return proxy The address of the created DisputeGame proxy.
+     */
+    function create(
+        GameType gameType,
+        Claim rootClaim,
+        bytes calldata extraData
+    ) external returns (IDisputeGame proxy);
+
+    /**
+     * @notice Sets the implementation contract for a specific `GameType`.
+     * @dev May only be called by the `owner`.
+     * @param gameType The type of the DisputeGame.
+     * @param impl The implementation contract for the given `GameType`.
+     */
+    function setImplementation(GameType gameType, IDisputeGame impl) external;
+}

packages/contracts-bedrock/contracts/dispute/IFaultDisputeGame.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import { Claim, ClaimHash, Clock, Bond, Position, Timestamp } from "../libraries/DisputeTypes.sol";
+
+import { IDisputeGame } from "./IDisputeGame.sol";
+
+/**
+ * @title IFaultDisputeGame
+ * @notice The interface for a fault proof backed dispute game.
+ */
+interface IFaultDisputeGame is IDisputeGame {
+    /**
+     * @notice Emitted when a subclaim is disagreed upon by `claimant`
+     * @dev Disagreeing with a subclaim is akin to attacking it.
+     * @param claimHash The unique ClaimHash that is being disagreed upon
+     * @param pivot The claim for the following pivot (disagreement = go left)
+     * @param claimant The address of the claimant
+     */
+    event Attack(ClaimHash indexed claimHash, Claim indexed pivot, address indexed claimant);
+
+    /**
+     * @notice Emitted when a subclaim is agreed upon by `claimant`
+     * @dev Agreeing with a subclaim is akin to defending it.
+     * @param claimHash The unique ClaimHash that is being agreed upon
+     * @param pivot The claim for the following pivot (agreement = go right)
+     * @param claimant The address of the claimant
+     */
+    event Defend(ClaimHash indexed claimHash, Claim indexed pivot, address indexed claimant);
+
+    /**
+     * @notice State variable of the starting timestamp of the game, set on deployment.
+     * @return The starting timestamp of the game
+     */
+    function gameStart() external view returns (Timestamp);
+
+    /**
+     * @notice Maps a unique ClaimHash to a Claim.
+     * @param claimHash The unique ClaimHash
+     * @return claim The Claim associated with the ClaimHash
+     */
+    function claims(ClaimHash claimHash) external view returns (Claim claim);
+
+    /**
+     * @notice Maps a unique ClaimHash to its parent.
+     * @param claimHash The unique ClaimHash
+     * @return parent The parent ClaimHash of the passed ClaimHash
+     */
+    function parents(ClaimHash claimHash) external view returns (ClaimHash parent);
+
+    /**
+     * @notice Maps a unique ClaimHash to its Position.
+     * @param claimHash The unique ClaimHash
+     * @return position The Position associated with the ClaimHash
+     */
+    function positions(ClaimHash claimHash) external view returns (Position position);
+
+    /**
+     * @notice Maps a unique ClaimHash to a Bond.
+     * @param claimHash The unique ClaimHash
+     * @return bond The Bond associated with the ClaimHash
+     */
+    function bonds(ClaimHash claimHash) external view returns (Bond bond);
+
+    /**
+     * @notice Maps a unique ClaimHash its chess clock.
+     * @param claimHash The unique ClaimHash
+     * @return clock The chess clock associated with the ClaimHash
+     */
+    function clocks(ClaimHash claimHash) external view returns (Clock clock);
+
+    /**
+     * @notice Maps a unique ClaimHash to its reference counter.
+     * @param claimHash The unique ClaimHash
+     * @return _rc The reference counter associated with the ClaimHash
+     */
+    function rc(ClaimHash claimHash) external view returns (uint64 _rc);
+
+    /**
+     * @notice Maps a unique ClaimHash to a boolean indicating whether or not it has been countered.
+     * @param claimHash The unique claimHash
+     * @return _countered Whether or not `claimHash` has been countered
+     */
+    function countered(ClaimHash claimHash) external view returns (bool _countered);
+
+    /**
+     * @notice Disagree with a subclaim
+     * @param disagreement The ClaimHash of the disagreement
+     * @param pivot The claimed pivot
+     */
+    function attack(ClaimHash disagreement, Claim pivot) external;
+
+    /**
+     * @notice Agree with a subclaim
+     * @param agreement The ClaimHash of the agreement
+     * @param pivot The claimed pivot
+     */
+    function defend(ClaimHash agreement, Claim pivot) external;
+
+    /**
+     * @notice Perform the final step via an on-chain fault proof processor
+     * @dev This function should point to a fault proof processor in order to execute
+     *      a step in the fault proof program on-chain. The interface of the fault proof
+     *      processor contract should be generic enough such that we can use different
+     *      fault proof VMs (MIPS, RiscV5, etc.)
+     * @param disagreement The ClaimHash of the disagreement
+     */
+    function step(ClaimHash disagreement) external;
+}

packages/contracts-bedrock/contracts/dispute/IInitializable.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+/**
+ * @title IInitializable
+ * @notice An interface for initializable contracts.
+ */
+interface IInitializable {
+    /**
+     * @notice Initializes the contract.
+     * @dev This function may only be called once.
+     */
+    function initialize() external;
+}

packages/contracts-bedrock/contracts/dispute/IOwnable.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+/**
+ * @title IOwnable
+ * @notice An interface for ownable contracts.
+ */
+interface IOwnable {
+    /**
+     * @notice Returns the owner of the contract
+     * @return _owner The address of the owner
+     */
+    function owner() external view returns (address _owner);
+
+    /**
+     * @notice Transfers ownership of the contract to a new address
+     * @dev May only be called by the contract owner
+     * @param newOwner The address to transfer ownership to
+     */
+    function transferOwnership(address newOwner) external;
+}

packages/contracts-bedrock/contracts/dispute/IVersioned.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+/**
+ * @title IVersioned
+ * @notice An interface for semantically versioned contracts.
+ */
+interface IVersioned {
+    /**
+     * @notice Returns the semantic version of the contract
+     * @return _version The semantic version of the contract
+     */
+    function version() external pure returns (string memory _version);
+}

packages/contracts-bedrock/contracts/libraries/DisputeTypes.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+/**
+ * @notice A custom type for a generic hash.
+ */
+type Hash is bytes32;
+
+/**
+ * @notice A claim represents an MPT root representing the state of the fault proof program.
+ */
+type Claim is bytes32;
+
+/**
+ * @notice A claim hash represents a hash of a claim and a position within the game tree.
+ * @dev Keccak hash of abi.encodePacked(Claim, Position);
+ */
+type ClaimHash is bytes32;
+
+/**
+ * @notice A bond represents the amount of collateral that a user has locked up in a claim.
+ */
+type Bond is uint256;
+
+/**
+ * @notice A dedicated timestamp type.
+ */
+type Timestamp is uint64;
+
+/**
+ * @notice A dedicated duration type.
+ * @dev Unit: seconds
+ */
+type Duration is uint64;
+
+/**
+ * @notice A `Clock` represents a packed `Duration` and `Timestamp`
+ * @dev The packed layout of this type is as follows:
+ * ┌────────────┬────────────────┐
+ * │    Bits    │     Value      │
+ * ├────────────┼────────────────┤
+ * │ [0, 128)   │ Duration       │
+ * │ [128, 256) │ Timestamp      │
+ * └────────────┴────────────────┘
+ */
+type Clock is uint256;
+
+/**
+ * @notice A `Position` represents a position of a claim within the game tree.
+ * @dev The packed layout of this type is as follows:
+ * ┌────────────┬────────────────┐
+ * │    Bits    │     Value      │
+ * ├────────────┼────────────────┤
+ * │ [0, 128)   │ Depth          │
+ * │ [128, 256) │ Index at depth │
+ * └────────────┴────────────────┘
+ */
+type Position is uint256;
+
+/**
+ * @notice The current status of the dispute game.
+ */
+enum GameStatus {
+    // The game is currently in progress, and has not been resolved.
+    IN_PROGRESS,
+    // The game has concluded, and the `rootClaim` was challenged successfully.
+    CHALLENGER_WINS,
+    // The game has concluded, and the `rootClaim` could not be contested.
+    DEFENDER_WINS
+}
+
+/**
+ * @notice The type of proof system being used.
+ */
+enum GameType {
+    // The game will use a `IDisputeGame` implementation that utilizes fault proofs.
+    FAULT,
+    // The game will use a `IDisputeGame` implementation that utilizes validity proofs.
+    VALIDITY,
+    // The game will use a `IDisputeGame` implementation that utilizes attestation proofs.
+    ATTESTATION
+}

packages/contracts-bedrock/deployments/final-migration-rehearsal/.chainId

-5
\ No newline at end of file

packages/sdk/src/interfaces/types.ts

@@ -29,6 +29,7 @@ export enum L2ChainID {
   OPTIMISM_HARDHAT_DEVNET = 17,
   OPTIMISM_BEDROCK_LOCAL_DEVNET = 901,
   OPTIMISM_BEDROCK_ALPHA_TESTNET = 28528,
+  BASE_GOERLI = 84531,
 }
 
 /**

packages/sdk/src/utils/chain-constants.ts

@@ -23,6 +23,7 @@ export const DEPOSIT_CONFIRMATION_BLOCKS: {
   [L2ChainID.OPTIMISM_HARDHAT_DEVNET]: 2 as const,
   [L2ChainID.OPTIMISM_BEDROCK_LOCAL_DEVNET]: 2 as const,
   [L2ChainID.OPTIMISM_BEDROCK_ALPHA_TESTNET]: 12 as const,
+  [L2ChainID.BASE_GOERLI]: 12 as const,
 }
 
 export const CHAIN_BLOCK_TIMES: {
@@ -157,6 +158,22 @@ export const CONTRACT_ADDRESSES: {
     },
     l2: DEFAULT_L2_CONTRACT_ADDRESSES,
   },
+  [L2ChainID.BASE_GOERLI]: {
+    l1: {
+      AddressManager: '0x4Cf6b56b14c6CFcB72A75611080514F94624c54e' as const,
+      L1CrossDomainMessenger:
+        '0x8e5693140eA606bcEB98761d9beB1BC87383706D' as const,
+      L1StandardBridge: '0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a' as const,
+      StateCommitmentChain:
+        '0x0000000000000000000000000000000000000000' as const,
+      CanonicalTransactionChain:
+        '0x0000000000000000000000000000000000000000' as const,
+      BondManager: '0x0000000000000000000000000000000000000000' as const,
+      OptimismPortal: '0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA' as const,
+      L2OutputOracle: '0x2A35891ff30313CcFa6CE88dcf3858bb075A2298' as const,
+    },
+    l2: DEFAULT_L2_CONTRACT_ADDRESSES,
+  },
 }
 
 /**