Merge branch 'develop' into willc/go-chi-latest

README.md

@@ -51,6 +51,36 @@ Refer to the Directory Structure section below to understand which packages are
 ~~ Production ~~
 ├── <a href="./packages">packages</a>
 │   ├── <a href="./packages/common-ts">common-ts</a>: Common tools for building apps in TypeScript
+│   ├── <a href="./packages/contracts-bedrock">contracts-bedrock</a>: Bedrock smart contracts.
+│   ├── <a href="./packages/contracts-periphery">contracts-periphery</a>: Peripheral contracts for Optimism
+│   ├── <a href="./packages/core-utils">core-utils</a>: Low-level utilities that make building Optimism easier
+│   ├── <a href="./packages/data-transport-layer">data-transport-layer</a>: Service for indexing Optimism-related L1 data
+│   ├── <a href="./packages/chain-mon">chain-mon</a>: Chain monitoring services
+│   ├── <a href="./packages/fault-detector">fault-detector</a>: Service for detecting Sequencer faults
+│   ├── <a href="./packages/message-relayer">message-relayer</a>: Tool for automatically relaying L1<>L2 messages in development
+│   ├── <a href="./packages/replica-healthcheck">replica-healthcheck</a>: Service for monitoring the health of a replica node
+│   └── <a href="./packages/sdk">sdk</a>: provides a set of tools for interacting with Optimism
+├── <a href="./op-bindings">op-bindings</a>: Go bindings for Bedrock smart contracts.
+├── <a href="./op-batcher">op-batcher</a>: L2-Batch Submitter, submits bundles of batches to L1
+├── <a href="./op-bootnode">op-bootnode</a>: Standalone op-node discovery bootnode
+├── <a href="./op-chain-ops">op-chain-ops</a>: State surgery utilities
+├── <a href="./op-challenger">op-challenger</a>: Dispute game challenge agent
+├── <a href="./op-e2e">op-e2e</a>: End-to-End testing of all bedrock components in Go
+├── <a href="./op-exporter">op-exporter</a>: Prometheus exporter client
+├── <a href="./op-heartbeat">op-heartbeat</a>: Heartbeat monitor service
+├── <a href="./op-node">op-node</a>: rollup consensus-layer client
+├── <a href="./op-program">op-program</a>: Fault proof program
+├── <a href="./op-proposer">op-proposer</a>: L2-Output Submitter, submits proposals to L1
+├── <a href="./op-service">op-service</a>: Common codebase utilities
+├── <a href="./op-signer">op-signer</a>: Client signer
+├── <a href="./op-wheel">op-wheel</a>: Database utilities
+├── <a href="./ops-bedrock">ops-bedrock</a>: Bedrock devnet work
+├── <a href="./proxyd">proxyd</a>: Configurable RPC request router and proxy
+└── <a href="./specs">specs</a>: Specs of the rollup starting at the Bedrock upgrade
+
+~~ Pre-BEDROCK ~~
+├── <a href="./packages">packages</a>
+│   ├── <a href="./packages/common-ts">common-ts</a>: Common tools for building apps in TypeScript
 │   ├── <a href="./packages/contracts">contracts</a>: L1 and L2 smart contracts for Optimism
 │   ├── <a href="./packages/contracts-periphery">contracts-periphery</a>: Peripheral contracts for Optimism
 │   ├── <a href="./packages/core-utils">core-utils</a>: Low-level utilities that make building Optimism easier
@@ -69,18 +99,7 @@ Refer to the Directory Structure section below to understand which packages are
 ├── <a href="./l2geth-exporter">l2geth-exporter</a>: A prometheus exporter to collect/serve metrics from an L2 geth node
 ├── <a href="./op-exporter">op-exporter</a>: A prometheus exporter to collect/serve metrics from an Optimism node
 ├── <a href="./proxyd">proxyd</a>: Configurable RPC request router and proxy
-├── <a href="./technical-documents">technical-documents</a>: audits and post-mortem documents
-
-~~ BEDROCK upgrade - Not production-ready yet, part of next major upgrade ~~
-├── <a href="./packages">packages</a>
-│   └── <a href="./packages/contracts-bedrock">contracts-bedrock</a>: Bedrock smart contracts. To be merged with ./packages/contracts.
-├── <a href="./op-bindings">op-bindings</a>: Go bindings for Bedrock smart contracts.
-├── <a href="./op-batcher">op-batcher</a>: L2-Batch Submitter, submits bundles of batches to L1
-├── <a href="./op-e2e">op-e2e</a>: End-to-End testing of all bedrock components in Go
-├── <a href="./op-node">op-node</a>: rollup consensus-layer client.
-├── <a href="./op-proposer">op-proposer</a>: L2-Output Submitter, submits proposals to L1
-├── <a href="./ops-bedrock">ops-bedrock</a>: Bedrock devnet work
-└── <a href="./specs">specs</a>: Specs of the rollup starting at the Bedrock upgrade
+└── <a href="./technical-documents">technical-documents</a>: audits and post-mortem documents
 </pre>
 
 ## Branching Model

go.mod

@@ -190,6 +190,6 @@ require (
 	nhooyr.io/websocket v1.8.7 // indirect
 )
 
-replace github.com/ethereum/go-ethereum v1.11.6 => github.com/ethereum-optimism/op-geth v1.101105.2-0.20230526154603-bdab05ca786f
+replace github.com/ethereum/go-ethereum v1.11.6 => github.com/ethereum-optimism/op-geth v1.101106.0-rc.2
 
 //replace github.com/ethereum/go-ethereum v1.11.6 => ../go-ethereum

go.sum

@@ -151,8 +151,8 @@ github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7
 github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3 h1:RWHKLhCrQThMfch+QJ1Z8veEq5ZO3DfIhZ7xgRP9WTc=
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3/go.mod h1:QziizLAiF0KqyLdNJYD7O5cpDlaFMNZzlxYNcWsJUxs=
-github.com/ethereum-optimism/op-geth v1.101105.2-0.20230526154603-bdab05ca786f h1:+yZN8K/4AIN5f+gazMwZAeqzDG2EL2GydMrccjnEK+A=
-github.com/ethereum-optimism/op-geth v1.101105.2-0.20230526154603-bdab05ca786f/go.mod h1:X9t7oeerFMU9/zMIjZKT/jbIca+O05QqtBTLjL+XVeA=
+github.com/ethereum-optimism/op-geth v1.101106.0-rc.2 h1:F3SGS0XIvRQ0MjL3Rzbx3A688hNsqv/DtdlBnZimFTw=
+github.com/ethereum-optimism/op-geth v1.101106.0-rc.2/go.mod h1:X9t7oeerFMU9/zMIjZKT/jbIca+O05QqtBTLjL+XVeA=
 github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fjl/memsize v0.0.1 h1:+zhkb+dhUgx0/e+M8sF0QqiouvMQUiKR+QYvdxIOKcQ=

op-batcher/batcher/channel_manager.go

@@ -228,6 +228,7 @@ func (s *channelManager) processBlocks() error {
 		}
 		blocksAdded += 1
 		latestL2ref = l2BlockRefFromBlockAndL1Info(block, l1info)
+		s.metr.RecordL2BlockInChannel(block)
 		// current block got added but channel is now full
 		if s.currentChannel.IsFull() {
 			break
@@ -298,6 +299,8 @@ func (s *channelManager) AddL2Block(block *types.Block) error {
 	if s.tip != (common.Hash{}) && s.tip != block.ParentHash() {
 		return ErrReorg
 	}
+
+	s.metr.RecordL2BlockInPendingQueue(block)
 	s.blocks = append(s.blocks, block)
 	s.tip = block.Hash()
 

op-batcher/metrics/metrics.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/prometheus/client_golang/prometheus"
@@ -30,6 +31,8 @@ type Metricer interface {
 	RecordL2BlocksLoaded(l2ref eth.L2BlockRef)
 	RecordChannelOpened(id derive.ChannelID, numPendingBlocks int)
 	RecordL2BlocksAdded(l2ref eth.L2BlockRef, numBlocksAdded, numPendingBlocks, inputBytes, outputComprBytes int)
+	RecordL2BlockInPendingQueue(block *types.Block)
+	RecordL2BlockInChannel(block *types.Block)
 	RecordChannelClosed(id derive.ChannelID, numPendingBlocks int, numFrames int, inputBytes int, outputComprBytes int, reason error)
 	RecordChannelFullySubmitted(id derive.ChannelID)
 	RecordChannelTimedOut(id derive.ChannelID)
@@ -55,8 +58,10 @@ type Metrics struct {
 	// label by openend, closed, fully_submitted, timed_out
 	channelEvs opmetrics.EventVec
 
-	pendingBlocksCount prometheus.GaugeVec
-	blocksAddedCount   prometheus.Gauge
+	pendingBlocksCount        prometheus.GaugeVec
+	pendingBlocksBytesTotal   prometheus.Counter
+	pendingBlocksBytesCurrent prometheus.Gauge
+	blocksAddedCount          prometheus.Gauge
 
 	channelInputBytes       prometheus.GaugeVec
 	channelReadyBytes       prometheus.Gauge
@@ -109,6 +114,16 @@ func NewMetrics(procName string) *Metrics {
 			Name:      "pending_blocks_count",
 			Help:      "Number of pending blocks, not added to a channel yet.",
 		}, []string{"stage"}),
+		pendingBlocksBytesTotal: factory.NewCounter(prometheus.CounterOpts{
+			Namespace: ns,
+			Name:      "pending_blocks_bytes_total",
+			Help:      "Total size of transactions in pending blocks as they are fetched from L2",
+		}),
+		pendingBlocksBytesCurrent: factory.NewGauge(prometheus.GaugeOpts{
+			Namespace: ns,
+			Name:      "pending_blocks_bytes_current",
+			Help:      "Current size of transactions in the pending (fetched from L2 but not in a channel) stage.",
+		}),
 		blocksAddedCount: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "blocks_added_count",
@@ -243,6 +258,18 @@ func (m *Metrics) RecordChannelClosed(id derive.ChannelID, numPendingBlocks int,
 	m.channelClosedReason.Set(float64(ClosedReasonToNum(reason)))
 }
 
+func (m *Metrics) RecordL2BlockInPendingQueue(block *types.Block) {
+	size := float64(estimateBatchSize(block))
+	m.pendingBlocksBytesTotal.Add(size)
+	m.pendingBlocksBytesCurrent.Add(size)
+}
+
+func (m *Metrics) RecordL2BlockInChannel(block *types.Block) {
+	size := float64(estimateBatchSize(block))
+	m.pendingBlocksBytesCurrent.Add(-1 * size)
+	// Refer to RecordL2BlocksAdded to see the current + count of bytes added to a channel
+}
+
 func ClosedReasonToNum(reason error) int {
 	// CLI-3640
 	return 0
@@ -267,3 +294,17 @@ func (m *Metrics) RecordBatchTxSuccess() {
 func (m *Metrics) RecordBatchTxFailed() {
 	m.batcherTxEvs.Record(TxStageFailed)
 }
+
+// estimateBatchSize estimates the size of the batch
+func estimateBatchSize(block *types.Block) uint64 {
+	size := uint64(70) // estimated overhead of batch metadata
+	for _, tx := range block.Transactions() {
+		// Don't include deposit transactions in the batch.
+		if tx.IsDepositTx() {
+			continue
+		}
+		// Add 2 for the overhead of encoding the tx bytes in a RLP list
+		size += tx.Size() + 2
+	}
+	return size
+}

op-batcher/metrics/noop.go

@@ -5,6 +5,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	txmetrics "github.com/ethereum-optimism/optimism/op-service/txmgr/metrics"
+	"github.com/ethereum/go-ethereum/core/types"
 )
 
 type noopMetrics struct {
@@ -23,6 +24,8 @@ func (*noopMetrics) RecordLatestL1Block(l1ref eth.L1BlockRef)               {}
 func (*noopMetrics) RecordL2BlocksLoaded(eth.L2BlockRef)                    {}
 func (*noopMetrics) RecordChannelOpened(derive.ChannelID, int)              {}
 func (*noopMetrics) RecordL2BlocksAdded(eth.L2BlockRef, int, int, int, int) {}
+func (*noopMetrics) RecordL2BlockInPendingQueue(*types.Block)               {}
+func (*noopMetrics) RecordL2BlockInChannel(*types.Block)                    {}
 
 func (*noopMetrics) RecordChannelClosed(derive.ChannelID, int, int, int, int, error) {}
 

op-e2e/system_test.go

@@ -1084,11 +1084,6 @@ func TestWithdrawals(t *testing.T) {
 	proveReceipt, finalizeReceipt := ProveAndFinalizeWithdrawal(t, cfg, l1Client, sys.Nodes["verifier"], ethPrivKey, receipt)
 
 	// Verify balance after withdrawal
-	ctx, cancel = context.WithTimeout(context.Background(), 1*time.Second)
-	defer cancel()
-	header, err = l1Client.HeaderByNumber(ctx, finalizeReceipt.BlockNumber)
-	require.Nil(t, err)
-
 	ctx, cancel = context.WithTimeout(context.Background(), 1*time.Second)
 	defer cancel()
 	endBalance, err = l1Client.BalanceAt(ctx, fromAddr, nil)
@@ -1098,7 +1093,9 @@ func TestWithdrawals(t *testing.T) {
 	// Fun fact, the fee is greater than the withdrawal amount
 	// NOTE: The gas fees include *both* the ProveWithdrawalTransaction and FinalizeWithdrawalTransaction transactions.
 	diff = new(big.Int).Sub(endBalance, startBalance)
-	fees = calcGasFees(proveReceipt.GasUsed+finalizeReceipt.GasUsed, tx.GasTipCap(), tx.GasFeeCap(), header.BaseFee)
+	proveFee := new(big.Int).Mul(new(big.Int).SetUint64(proveReceipt.GasUsed), proveReceipt.EffectiveGasPrice)
+	finalizeFee := new(big.Int).Mul(new(big.Int).SetUint64(finalizeReceipt.GasUsed), finalizeReceipt.EffectiveGasPrice)
+	fees = new(big.Int).Add(proveFee, finalizeFee)
 	withdrawAmount = withdrawAmount.Sub(withdrawAmount, fees)
 	require.Equal(t, withdrawAmount, diff)
 }

op-node/sources/receipts.go

@@ -179,6 +179,7 @@ func (r ReceiptsFetchingMethod) String() string {
 	addMaybe(DebugGetRawReceipts, "debug_getRawReceipts")
 	addMaybe(ParityGetBlockReceipts, "parity_getBlockReceipts")
 	addMaybe(EthGetBlockReceipts, "eth_getBlockReceipts")
+	addMaybe(ErigonGetBlockReceiptsByBlockHash, "erigon_getBlockReceiptsByBlockHash")
 	addMaybe(^ReceiptsFetchingMethod(0), "unknown") // if anything is left, describe it as unknown
 	return out
 }
@@ -230,10 +231,9 @@ const (
 	//   - Nethermind: https://docs.nethermind.io/nethermind/ethereum-client/json-rpc/parity#parity_getblockreceipts
 	ParityGetBlockReceipts
 	// EthGetBlockReceipts is a non-standard receipt fetching method in the eth namespace,
-	// supported by some RPC platforms and Erigon.
+	// supported by some RPC platforms.
 	// Available in:
 	//   - Alchemy: 500 CU total  (and deprecated)
-	//   - Erigon: free
 	//   - QuickNode: 59 credits total       (does not seem to work with block hash arg, inaccurate docs)
 	// Method: eth_getBlockReceipts
 	// Params:
@@ -243,7 +243,21 @@ const (
 	// See:
 	//   - QuickNode: https://www.quicknode.com/docs/ethereum/eth_getBlockReceipts
 	//   - Alchemy: https://docs.alchemy.com/reference/eth-getblockreceipts
+	// Erigon has this available, but does not support block-hash argument to the method:
+	// https://github.com/ledgerwatch/erigon/blob/287a3d1d6c90fc6a7a088b5ae320f93600d5a167/cmd/rpcdaemon/commands/eth_receipts.go#L571
 	EthGetBlockReceipts
+	// ErigonGetBlockReceiptsByBlockHash is an Erigon-specific receipt fetching method,
+	// the same as EthGetBlockReceipts but supporting a block-hash argument.
+	// Available in:
+	//   - Erigon
+	// Method: erigon_getBlockReceiptsByBlockHash
+	// Params:
+	//  - Erigon: string, hex-encoded block hash
+	// Returns:
+	//  - Erigon: array of json-ified receipts
+	// See:
+	// https://github.com/ledgerwatch/erigon/blob/287a3d1d6c90fc6a7a088b5ae320f93600d5a167/cmd/rpcdaemon/commands/erigon_receipts.go#LL391C24-L391C51
+	ErigonGetBlockReceiptsByBlockHash
 
 	// Other:
 	//  - 250 credits, not supported, strictly worse than other options. In quicknode price-table.
@@ -269,13 +283,14 @@ func AvailableReceiptsFetchingMethods(kind RPCProviderKind) ReceiptsFetchingMeth
 	case RPCKindDebugGeth:
 		return DebugGetRawReceipts | EthGetTransactionReceiptBatch
 	case RPCKindErigon:
-		return EthGetBlockReceipts | EthGetTransactionReceiptBatch
+		return ErigonGetBlockReceiptsByBlockHash | EthGetTransactionReceiptBatch
 	case RPCKindBasic:
 		return EthGetTransactionReceiptBatch
 	case RPCKindAny:
 		// if it's any kind of RPC provider, then try all methods
 		return AlchemyGetTransactionReceipts | EthGetBlockReceipts |
-			DebugGetRawReceipts | ParityGetBlockReceipts | EthGetTransactionReceiptBatch
+			DebugGetRawReceipts | ErigonGetBlockReceiptsByBlockHash |
+			ParityGetBlockReceipts | EthGetTransactionReceiptBatch
 	default:
 		return EthGetTransactionReceiptBatch
 	}
@@ -310,6 +325,9 @@ func PickBestReceiptsFetchingMethod(kind RPCProviderKind, available ReceiptsFetc
 	if available&DebugGetRawReceipts != 0 {
 		return DebugGetRawReceipts
 	}
+	if available&ErigonGetBlockReceiptsByBlockHash != 0 {
+		return ErigonGetBlockReceiptsByBlockHash
+	}
 	if available&EthGetBlockReceipts != 0 {
 		return EthGetBlockReceipts
 	}
@@ -428,6 +446,8 @@ func (job *receiptsFetchingJob) runAltMethod(ctx context.Context, m ReceiptsFetc
 		err = job.client.CallContext(ctx, &result, "parity_getBlockReceipts", job.block.Hash)
 	case EthGetBlockReceipts:
 		err = job.client.CallContext(ctx, &result, "eth_getBlockReceipts", job.block.Hash)
+	case ErigonGetBlockReceiptsByBlockHash:
+		err = job.client.CallContext(ctx, &result, "erigon_getBlockReceiptsByBlockHash", job.block.Hash)
 	default:
 		err = fmt.Errorf("unknown receipt fetching method: %d", uint64(m))
 	}

op-node/sources/receipts_test.go

@@ -40,6 +40,15 @@ func (b *ethBackend) GetBlockReceipts(id string) ([]*types.Receipt, error) {
 	return out[0].([]*types.Receipt), *out[1].(*error)
 }
 
+type erigonBackend struct {
+	*mock.Mock
+}
+
+func (b *erigonBackend) GetBlockReceiptsByBlockHash(id string) ([]*types.Receipt, error) {
+	out := b.Mock.MethodCalled("erigon_getBlockReceiptsByBlockHash", id)
+	return out[0].([]*types.Receipt), *out[1].(*error)
+}
+
 type alchemyBackend struct {
 	*mock.Mock
 }
@@ -99,6 +108,7 @@ func (tc *ReceiptsTestCase) Run(t *testing.T) {
 	require.NoError(t, srv.RegisterName("alchemy", &alchemyBackend{Mock: m}))
 	require.NoError(t, srv.RegisterName("debug", &debugBackend{Mock: m}))
 	require.NoError(t, srv.RegisterName("parity", &parityBackend{Mock: m}))
+	require.NoError(t, srv.RegisterName("erigon", &erigonBackend{Mock: m}))
 
 	block, requests := tc.setup(t)
 
@@ -127,6 +137,8 @@ func (tc *ReceiptsTestCase) Run(t *testing.T) {
 			m.On("parity_getBlockReceipts", block.Hash.String()).Once().Return(req.result, &req.err)
 		case EthGetBlockReceipts:
 			m.On("eth_getBlockReceipts", block.Hash.String()).Once().Return(req.result, &req.err)
+		case ErigonGetBlockReceiptsByBlockHash:
+			m.On("erigon_getBlockReceiptsByBlockHash", block.Hash.String()).Once().Return(req.result, &req.err)
 		default:
 			t.Fatalf("unrecognized request method: %d", uint64(req.method))
 		}
@@ -286,7 +298,7 @@ func TestEthClient_FetchReceipts(t *testing.T) {
 		{
 			name:         "erigon",
 			providerKind: RPCKindErigon,
-			setup:        fallbackCase(4, EthGetBlockReceipts),
+			setup:        fallbackCase(4, ErigonGetBlockReceiptsByBlockHash),
 		},
 		{
 			name:         "basic",
@@ -305,6 +317,7 @@ func TestEthClient_FetchReceipts(t *testing.T) {
 			setup: fallbackCase(4,
 				AlchemyGetTransactionReceipts,
 				DebugGetRawReceipts,
+				ErigonGetBlockReceiptsByBlockHash,
 				EthGetBlockReceipts,
 				ParityGetBlockReceipts,
 			),

packages/contracts-bedrock/.storage-layout

@@ -248,3 +248,21 @@
 
 | Name | Type | Slot | Offset | Bytes | Contract |
 |------|------|------|--------|-------|----------|
+
+=======================
+➡ contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory
+=======================
+
+| Name         | Type                                            | Slot | Offset | Bytes | Contract                                                    |
+|--------------|-------------------------------------------------|------|--------|-------|-------------------------------------------------------------|
+| _owner       | address                                         | 0    | 0      | 20    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| gameImpls    | mapping(enum GameType => contract IDisputeGame) | 1    | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| disputeGames | mapping(Hash => contract IDisputeGame)          | 2    | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+
+=======================
+➡ contracts/dispute/BondManager.sol:BondManager
+=======================
+
+| Name  | Type                                        | Slot | Offset | Bytes | Contract                                      |
+|-------|---------------------------------------------|------|--------|-------|-----------------------------------------------|
+| bonds | mapping(bytes32 => struct BondManager.Bond) | 0    | 0      | 32    | contracts/dispute/BondManager.sol:BondManager |

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

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import { GameType } from "../libraries/DisputeTypes.sol";
-import { GameStatus } from "../libraries/DisputeTypes.sol";
+import "../libraries/DisputeTypes.sol";
+
 import { SafeCall } from "../libraries/SafeCall.sol";
 
-import { IDisputeGame } from "./IDisputeGame.sol";
-import { IDisputeGameFactory } from "./IDisputeGameFactory.sol";
+import { IDisputeGame } from "./interfaces/IDisputeGame.sol";
+import { IDisputeGameFactory } from "./interfaces/IDisputeGameFactory.sol";
+import { IBondManager } from "./interfaces/IBondManager.sol";
 
 /**
  * @title BondManager
  * @notice The Bond Manager serves as an escrow for permissionless output proposal bonds.
  */
-contract BondManager {
+contract BondManager is IBondManager {
     /**
      * @notice The Bond Type
      */
     struct Bond {
         address owner;
-        uint256 expiration;
         bytes32 id;
-        uint256 amount;
+        uint128 expiration;
+        uint128 amount;
     }
 
-    /**
-     * @notice Mapping from bondId to bond.
-     */
-    mapping(bytes32 => Bond) public bonds;
-
-    /**
-     * @notice BondPosted is emitted when a bond is posted.
-     * @param bondId is the id of the bond.
-     * @param owner is the address that owns the bond.
-     * @param expiration is the time at which the bond expires.
-     * @param amount is the amount of the bond.
-     */
-    event BondPosted(bytes32 bondId, address owner, uint256 expiration, uint256 amount);
-
-    /**
-     * @notice BondSeized is emitted when a bond is seized.
-     * @param bondId is the id of the bond.
-     * @param owner is the address that owns the bond.
-     * @param seizer is the address that seized the bond.
-     * @param amount is the amount of the bond.
-     */
-    event BondSeized(bytes32 bondId, address owner, address seizer, uint256 amount);
-
-    /**
-     * @notice BondReclaimed is emitted when a bond is reclaimed by the owner.
-     * @param bondId is the id of the bond.
-     * @param claiment is the address that reclaimed the bond.
-     * @param amount is the amount of the bond.
-     */
-    event BondReclaimed(bytes32 bondId, address claiment, uint256 amount);
-
     /**
      * @notice The permissioned dispute game factory.
      * @dev Used to verify the status of bonds.
@@ -67,6 +37,11 @@ contract BondManager {
      */
     uint256 private constant TRANSFER_GAS = 30_000;
 
+    /**
+     * @notice Mapping from bondId to bond.
+     */
+    mapping(bytes32 => Bond) public bonds;
+
     /**
      * @notice Instantiates the bond maanger with the registered dispute game factory.
      * @param _disputeGameFactory is the dispute game factory.
@@ -76,37 +51,30 @@ contract BondManager {
     }
 
     /**
-     * @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 _bondOwner is the address that owns the bond.
-     * @param _minClaimHold is the minimum amount of time the owner
-     *        must wait before reclaiming their bond.
+     * @inheritdoc IBondManager
      */
     function post(
         bytes32 _bondId,
         address _bondOwner,
-        uint256 _minClaimHold
+        uint128 _minClaimHold
     ) external payable {
         require(bonds[_bondId].owner == address(0), "BondManager: BondId already posted.");
         require(_bondOwner != address(0), "BondManager: Owner cannot be the zero address.");
         require(msg.value > 0, "BondManager: Value must be non-zero.");
 
-        uint256 expiration = _minClaimHold + block.timestamp;
+        uint128 expiration = uint128(_minClaimHold + block.timestamp);
         bonds[_bondId] = Bond({
             owner: _bondOwner,
-            expiration: expiration,
             id: _bondId,
-            amount: msg.value
+            expiration: expiration,
+            amount: uint128(msg.value)
         });
 
         emit BondPosted(_bondId, _bondOwner, expiration, msg.value);
     }
 
     /**
-     * @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.
+     * @inheritdoc IBondManager
      */
     function seize(bytes32 _bondId) external {
         Bond memory b = bonds[_bondId];
@@ -131,10 +99,7 @@ contract BondManager {
     }
 
     /**
-     * @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 _claimRecipients is a set of addresses to split the bond amongst.
+     * @inheritdoc IBondManager
      */
     function seizeAndSplit(bytes32 _bondId, address[] calldata _claimRecipients) external {
         Bond memory b = bonds[_bondId];
@@ -168,9 +133,7 @@ contract BondManager {
     }
 
     /**
-     * @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.
+     * @inheritdoc IBondManager
      */
     function reclaim(bytes32 _bondId) external {
         Bond memory b = bonds[_bondId];

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

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
+import "../libraries/DisputeTypes.sol";
+import "../libraries/DisputeErrors.sol";
+
 import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
 import { ClonesWithImmutableArgs } from "@cwia/ClonesWithImmutableArgs.sol";
 
-import { Claim } from "../libraries/DisputeTypes.sol";
-import { Hash } from "../libraries/DisputeTypes.sol";
-import { GameType } from "../libraries/DisputeTypes.sol";
-
-import { NoImplementation } from "../libraries/DisputeErrors.sol";
-import { GameAlreadyExists } from "../libraries/DisputeErrors.sol";
-
-import { IDisputeGame } from "./IDisputeGame.sol";
-import { IDisputeGameFactory } from "./IDisputeGameFactory.sol";
+import { IDisputeGame } from "./interfaces/IDisputeGame.sol";
+import { IDisputeGameFactory } from "./interfaces/IDisputeGameFactory.sol";
 
 /**
  * @title DisputeGameFactory
@@ -25,7 +21,7 @@ contract DisputeGameFactory is Ownable, IDisputeGameFactory {
     using ClonesWithImmutableArgs for address;
 
     /**
-     * @notice Mapping of `GameType`s to their respective `IDisputeGame` implementations.
+     * @inheritdoc IDisputeGameFactory
      */
     mapping(GameType => IDisputeGame) public gameImpls;
 
@@ -45,16 +41,7 @@ contract DisputeGameFactory is Ownable, IDisputeGameFactory {
     }
 
     /**
-     * @notice Retrieves the hash of `gameType . rootClaim . extraData`
-     *         to the deployed `DisputeGame` clone.
-     * @dev Note: `.` denotes concatenation.
-     * @param gameType The type of the DisputeGame.
-     *        Used to decide the implementation to clone.
-     * @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. `address(0)` if nonexistent.
+     * @inheritdoc IDisputeGameFactory
      */
     function games(
         GameType gameType,
@@ -65,15 +52,7 @@ contract DisputeGameFactory is Ownable, IDisputeGameFactory {
     }
 
     /**
-     * @notice Creates a new DisputeGame proxy contract.
-     * @notice If a dispute game with the given parameters already exists,
-     *         it will be returned.
-     * @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`.
+     * @inheritdoc IDisputeGameFactory
      */
     function create(
         GameType gameType,
@@ -89,8 +68,7 @@ contract DisputeGameFactory is Ownable, IDisputeGameFactory {
         }
 
         // Clone the implementation contract and initialize it with the given parameters.
-        bytes memory data = abi.encodePacked(rootClaim, extraData);
-        proxy = IDisputeGame(address(impl).clone(data));
+        proxy = IDisputeGame(address(impl).clone(abi.encodePacked(rootClaim, extraData)));
         proxy.initialize();
 
         // Compute the unique identifier for the dispute game.
@@ -107,23 +85,7 @@ contract DisputeGameFactory is Ownable, IDisputeGameFactory {
     }
 
     /**
-     * @notice Sets the implementation contract for a specific `GameType`.
-     * @param gameType The type of the DisputeGame.
-     * @param impl The implementation contract for the given `GameType`.
-     */
-    function setImplementation(GameType gameType, IDisputeGame impl) external onlyOwner {
-        gameImpls[gameType] = impl;
-        emit ImplementationSet(address(impl), gameType);
-    }
-
-    /**
-     * @notice Returns a unique identifier for the given dispute game parameters.
-     * @dev Hashes the concatenation of `gameType . rootClaim . extraData`
-     *      without expanding memory.
-     * @param gameType The type of the DisputeGame.
-     * @param rootClaim The root claim of the DisputeGame.
-     * @param extraData Any extra data that should be provided to the created dispute game.
-     * @return _uuid The unique identifier for the given dispute game parameters.
+     * @inheritdoc IDisputeGameFactory
      */
     function getGameUUID(
         GameType gameType,
@@ -160,4 +122,12 @@ contract DisputeGameFactory is Ownable, IDisputeGameFactory {
             mstore(pointerOffset, tempC)
         }
     }
+
+    /**
+     * @inheritdoc IDisputeGameFactory
+     */
+    function setImplementation(GameType gameType, IDisputeGame impl) external onlyOwner {
+        gameImpls[gameType] = impl;
+        emit ImplementationSet(address(impl), gameType);
+    }
 }

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 → packages/contracts-bedrock/contracts/dispute/interfaces/IBondManager.sol

@@ -6,6 +6,32 @@ pragma solidity ^0.8.15;
  * @notice The Bond Manager holds ether posted as a bond for a bond id.
  */
 interface IBondManager {
+    /**
+     * @notice BondPosted is emitted when a bond is posted.
+     * @param bondId is the id of the bond.
+     * @param owner is the address that owns the bond.
+     * @param expiration is the time at which the bond expires.
+     * @param amount is the amount of the bond.
+     */
+    event BondPosted(bytes32 bondId, address owner, uint256 expiration, uint256 amount);
+
+    /**
+     * @notice BondSeized is emitted when a bond is seized.
+     * @param bondId is the id of the bond.
+     * @param owner is the address that owns the bond.
+     * @param seizer is the address that seized the bond.
+     * @param amount is the amount of the bond.
+     */
+    event BondSeized(bytes32 bondId, address owner, address seizer, uint256 amount);
+
+    /**
+     * @notice BondReclaimed is emitted when a bond is reclaimed by the owner.
+     * @param bondId is the id of the bond.
+     * @param claiment is the address that reclaimed the bond.
+     * @param amount is the amount of the bond.
+     */
+    event BondReclaimed(bytes32 bondId, address claiment, uint256 amount);
+
     /**
      * @notice Post a bond with a given id and owner.
      * @dev This function will revert if the provided bondId is already in use.
@@ -17,7 +43,7 @@ interface IBondManager {
     function post(
         bytes32 _bondId,
         address _bondOwner,
-        uint256 _minClaimHold
+        uint128 _minClaimHold
     ) external payable;
 
     /**

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

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import { Claim } from "../libraries/DisputeTypes.sol";
-import { GameType } from "../libraries/DisputeTypes.sol";
-import { GameStatus } from "../libraries/DisputeTypes.sol";
-import { Timestamp } from "../libraries/DisputeTypes.sol";
+import "../../libraries/DisputeTypes.sol";
 
 import { IVersioned } from "./IVersioned.sol";
 import { IBondManager } from "./IBondManager.sol";
@@ -21,8 +18,6 @@ interface IDisputeGame is IInitializable, IVersioned {
      */
     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.
@@ -42,21 +37,21 @@ interface IDisputeGame is IInitializable, IVersioned {
      *      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);
+    function gameType() external pure 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);
+    function rootClaim() external pure 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);
+    function extraData() external pure returns (bytes memory _extraData);
 
     /**
      * @notice Returns the address of the `BondManager` used.
@@ -73,4 +68,19 @@ interface IDisputeGame is IInitializable, IVersioned {
      * @return _status The status of the game after resolution.
      */
     function resolve() external returns (GameStatus _status);
+
+    /**
+     * @notice A compliant implementation of this interface should return the components of the
+     *         game UUID's preimage provided in the cwia payload. The preimage of the UUID is
+     *         constructed as `keccak256(gameType . rootClaim . extraData)` where `.` denotes
+     *         concatenation.
+     */
+    function gameData()
+        external
+        pure
+        returns (
+            GameType _gameType,
+            Claim _rootClaim,
+            bytes memory _extraData
+        );
 }

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

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import { Claim } from "../libraries/DisputeTypes.sol";
-import { GameType } from "../libraries/DisputeTypes.sol";
+import "../../libraries/DisputeTypes.sol";
 
 import { IDisputeGame } from "./IDisputeGame.sol";
 
@@ -75,4 +74,19 @@ interface IDisputeGameFactory {
      * @param impl The implementation contract for the given `GameType`.
      */
     function setImplementation(GameType gameType, IDisputeGame impl) external;
+
+    /**
+     * @notice Returns a unique identifier for the given dispute game parameters.
+     * @dev Hashes the concatenation of `gameType . rootClaim . extraData`
+     *      without expanding memory.
+     * @param gameType The type of the DisputeGame.
+     * @param rootClaim The root claim of the DisputeGame.
+     * @param extraData Any extra data that should be provided to the created dispute game.
+     * @return _uuid The unique identifier for the given dispute game parameters.
+     */
+    function getGameUUID(
+        GameType gameType,
+        Claim rootClaim,
+        bytes memory extraData
+    ) external pure returns (Hash _uuid);
 }

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

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import { Clock } from "../libraries/DisputeTypes.sol";
-import { Claim } from "../libraries/DisputeTypes.sol";
-import { Position } from "../libraries/DisputeTypes.sol";
-import { Timestamp } from "../libraries/DisputeTypes.sol";
-import { ClaimHash } from "../libraries/DisputeTypes.sol";
-import { BondAmount } from "../libraries/DisputeTypes.sol";
+import "../../libraries/DisputeTypes.sol";
 
 import { IDisputeGame } from "./IDisputeGame.sol";
 
@@ -33,12 +28,6 @@ interface IFaultDisputeGame is IDisputeGame {
      */
     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

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

+// SPDX-License-Identifier: BSD
+pragma solidity ^0.8.15;
+
+// solhint-disable
+/**
+ * @title Clone
+ * @author zefram.eth, Saw-mon & Natalie, clabby
+ * @notice Provides helper functions for reading immutable args from calldata
+ * @dev Original: https://github.com/Saw-mon-and-Natalie/clones-with-immutable-args/blob/105efee1b9127ed7f6fedf139e1fc796ce8791f2/src/Clone.sol
+ * @dev MODIFICATIONS:
+ *      - Added `_getArgDynBytes` function.
+ */
+// solhint-enable
+contract Clone {
+    uint256 private constant ONE_WORD = 0x20;
+
+    /**
+     * @notice Reads an immutable arg with type address
+     * @param argOffset The offset of the arg in the packed data
+     * @return arg The arg value
+     */
+    function _getArgAddress(uint256 argOffset) internal pure returns (address arg) {
+        uint256 offset = _getImmutableArgsOffset();
+        assembly {
+            arg := shr(0x60, calldataload(add(offset, argOffset)))
+        }
+    }
+
+    /**
+     * @notice Reads an immutable arg with type uint256
+     * @param argOffset The offset of the arg in the packed data
+     * @return arg The arg value
+     */
+    function _getArgUint256(uint256 argOffset) internal pure returns (uint256 arg) {
+        uint256 offset = _getImmutableArgsOffset();
+        assembly {
+            arg := calldataload(add(offset, argOffset))
+        }
+    }
+
+    /**
+     * @notice Reads an immutable arg with type bytes32
+     * @param argOffset The offset of the arg in the packed data
+     * @return arg The arg value
+     */
+    function _getArgFixedBytes(uint256 argOffset) internal pure returns (bytes32 arg) {
+        uint256 offset = _getImmutableArgsOffset();
+        assembly {
+            arg := calldataload(add(offset, argOffset))
+        }
+    }
+
+    /**
+     * @notice Reads a uint256 array stored in the immutable args.
+     * @param argOffset The offset of the arg in the packed data
+     * @param arrLen Number of elements in the array
+     * @return arr The array
+     */
+    function _getArgUint256Array(uint256 argOffset, uint64 arrLen)
+        internal
+        pure
+        returns (uint256[] memory arr)
+    {
+        uint256 offset = _getImmutableArgsOffset() + argOffset;
+        arr = new uint256[](arrLen);
+
+        assembly {
+            calldatacopy(add(arr, ONE_WORD), offset, shl(5, arrLen))
+        }
+    }
+
+    /**
+     * @notice Reads a dynamic bytes array stored in the immutable args.
+     * @param argOffset The offset of the arg in the packed data
+     * @param arrLen Number of elements in the array
+     * @return arr The array
+     */
+    function _getArgDynBytes(uint256 argOffset, uint64 arrLen)
+        internal
+        pure
+        returns (bytes memory arr)
+    {
+        uint256 offset = _getImmutableArgsOffset() + argOffset;
+        arr = new bytes(arrLen);
+
+        assembly {
+            calldatacopy(add(arr, ONE_WORD), offset, arrLen)
+        }
+    }
+
+    /**
+     * @notice Reads an immutable arg with type uint64
+     * @param argOffset The offset of the arg in the packed data
+     * @return arg The arg value
+     */
+    function _getArgUint64(uint256 argOffset) internal pure returns (uint64 arg) {
+        uint256 offset = _getImmutableArgsOffset();
+        assembly {
+            arg := shr(0xc0, calldataload(add(offset, argOffset)))
+        }
+    }
+
+    /**
+     * @notice Reads an immutable arg with type uint8
+     * @param argOffset The offset of the arg in the packed data
+     * @return arg The arg value
+     */
+    function _getArgUint8(uint256 argOffset) internal pure returns (uint8 arg) {
+        uint256 offset = _getImmutableArgsOffset();
+        assembly {
+            arg := shr(0xf8, calldataload(add(offset, argOffset)))
+        }
+    }
+
+    /**
+     * @return offset The offset of the packed immutable args in calldata
+     */
+    function _getImmutableArgsOffset() internal pure returns (uint256 offset) {
+        assembly {
+            offset := sub(calldatasize(), shr(0xf0, calldataload(sub(calldatasize(), 2))))
+        }
+    }
+}

packages/contracts-bedrock/contracts/test/BondManager.t.sol

@@ -5,8 +5,8 @@ import "forge-std/Test.sol";
 
 import "../libraries/DisputeTypes.sol";
 
-import { IDisputeGame } from "../dispute/IDisputeGame.sol";
-import { IBondManager } from "../dispute/IBondManager.sol";
+import { IDisputeGame } from "../dispute/interfaces/IDisputeGame.sol";
+import { IBondManager } from "../dispute/interfaces/IBondManager.sol";
 
 import { DisputeGameFactory } from "../dispute/DisputeGameFactory.sol";
 
@@ -45,23 +45,21 @@ contract BondManager_Test is Test {
     function testFuzz_post_succeeds(
         bytes32 bondId,
         address owner,
-        uint256 minClaimHold,
-        uint256 amount
+        uint128 minClaimHold,
+        uint128 amount
     ) public {
         vm.assume(owner != address(0));
         vm.assume(owner != address(bm));
         vm.assume(owner != address(this));
         // Create2Deployer
         vm.assume(owner != address(0x4e59b44847b379578588920cA78FbF26c0B4956C));
-        vm.assume(amount != 0);
-        unchecked {
-            vm.assume(block.timestamp + minClaimHold > minClaimHold);
-        }
+        amount = uint128(bound(amount, 1, type(uint128).max));
+        minClaimHold = uint128(bound(minClaimHold, 0, type(uint128).max - block.timestamp));
 
         vm.deal(address(this), amount);
 
         vm.expectEmit(true, true, true, true);
-        uint256 expiration = block.timestamp + minClaimHold;
+        uint128 expiration = uint128(block.timestamp + minClaimHold);
         emit BondPosted(bondId, owner, expiration, amount);
 
         bm.post{ value: amount }(bondId, owner, minClaimHold);
@@ -69,9 +67,9 @@ contract BondManager_Test is Test {
         // Validate the bond
         (
             address newFetchedOwner,
-            uint256 fetchedExpiration,
             bytes32 fetchedBondId,
-            uint256 bondAmount
+            uint128 fetchedExpiration,
+            uint128 bondAmount
         ) = bm.bonds(bondId);
         assertEq(newFetchedOwner, owner);
         assertEq(fetchedExpiration, block.timestamp + minClaimHold);
@@ -85,15 +83,13 @@ contract BondManager_Test is Test {
     function testFuzz_post_duplicates_reverts(
         bytes32 bondId,
         address owner,
-        uint256 minClaimHold,
-        uint256 amount
+        uint128 minClaimHold,
+        uint128 amount
     ) public {
         vm.assume(owner != address(0));
         amount = amount / 2;
-        vm.assume(amount != 0);
-        unchecked {
-            vm.assume(block.timestamp + minClaimHold > minClaimHold);
-        }
+        amount = uint128(bound(amount, 1, type(uint128).max));
+        minClaimHold = uint128(bound(minClaimHold, 0, type(uint128).max - block.timestamp));
 
         vm.deal(address(this), amount);
         bm.post{ value: amount }(bondId, owner, minClaimHold);
@@ -108,8 +104,8 @@ contract BondManager_Test is Test {
      */
     function testFuzz_post_zeroAddress_reverts(
         bytes32 bondId,
-        uint256 minClaimHold,
-        uint256 amount
+        uint128 minClaimHold,
+        uint128 amount
     ) public {
         address owner = address(0);
         vm.deal(address(this), amount);
@@ -123,10 +119,10 @@ contract BondManager_Test is Test {
     function testFuzz_post_zeroAddress_reverts(
         bytes32 bondId,
         address owner,
-        uint256 minClaimHold
+        uint128 minClaimHold
     ) public {
         vm.assume(owner != address(0));
-        uint256 amount = 0;
+        uint128 amount = 0;
         vm.deal(address(this), amount);
         vm.expectRevert("BondManager: Value must be non-zero.");
         bm.post{ value: amount }(bondId, owner, minClaimHold);
@@ -152,16 +148,14 @@ contract BondManager_Test is Test {
     function testFuzz_seize_expired_reverts(
         bytes32 bondId,
         address owner,
-        uint256 minClaimHold,
-        uint256 amount
+        uint128 minClaimHold,
+        uint128 amount
     ) public {
         vm.assume(owner != address(0));
         vm.assume(owner != address(bm));
         vm.assume(owner != address(this));
-        vm.assume(amount != 0);
-        unchecked {
-            vm.assume(block.timestamp + minClaimHold + 1 > minClaimHold);
-        }
+        amount = uint128(bound(amount, 1, type(uint128).max));
+        minClaimHold = uint128(bound(minClaimHold, 0, type(uint128).max - block.timestamp));
         vm.deal(address(this), amount);
         bm.post{ value: amount }(bondId, owner, minClaimHold);
 
@@ -176,16 +170,15 @@ contract BondManager_Test is Test {
     function testFuzz_seize_unauthorized_reverts(
         bytes32 bondId,
         address owner,
-        uint256 minClaimHold,
-        uint256 amount
+        uint128 minClaimHold,
+        uint128 amount
     ) public {
         vm.assume(owner != address(0));
         vm.assume(owner != address(bm));
         vm.assume(owner != address(this));
-        vm.assume(amount != 0);
-        unchecked {
-            vm.assume(block.timestamp + minClaimHold > minClaimHold);
-        }
+        amount = uint128(bound(amount, 1, type(uint128).max));
+        minClaimHold = uint128(bound(minClaimHold, 0, type(uint128).max - block.timestamp));
+
         vm.deal(address(this), amount);
         bm.post{ value: amount }(bondId, owner, minClaimHold);
 
@@ -200,12 +193,10 @@ contract BondManager_Test is Test {
      */
     function testFuzz_seize_succeeds(
         bytes32 bondId,
-        uint256 minClaimHold,
+        uint128 minClaimHold,
         bytes calldata extraData
     ) public {
-        unchecked {
-            vm.assume(block.timestamp + minClaimHold > minClaimHold);
-        }
+        minClaimHold = uint128(bound(minClaimHold, 0, type(uint128).max - block.timestamp));
 
         vm.deal(address(this), 1 ether);
         bm.post{ value: 1 ether }(bondId, address(0xba5ed), minClaimHold);
@@ -255,12 +246,10 @@ contract BondManager_Test is Test {
      */
     function testFuzz_seizeAndSplit_succeeds(
         bytes32 bondId,
-        uint256 minClaimHold,
+        uint128 minClaimHold,
         bytes calldata extraData
     ) public {
-        unchecked {
-            vm.assume(block.timestamp + minClaimHold > minClaimHold);
-        }
+        minClaimHold = uint128(bound(minClaimHold, 0, type(uint128).max - block.timestamp));
 
         vm.deal(address(this), 1 ether);
         bm.post{ value: 1 ether }(bondId, address(0xba5ed), minClaimHold);
@@ -316,15 +305,16 @@ contract BondManager_Test is Test {
     function testFuzz_reclaim_succeeds(
         bytes32 bondId,
         address owner,
-        uint256 minClaimHold,
-        uint256 amount
+        uint128 minClaimHold,
+        uint128 amount
     ) public {
+        vm.assume(owner != address(factory));
+        vm.assume(owner != address(bm));
+        vm.assume(owner != address(this));
         vm.assume(owner != address(0));
         vm.assume(owner.code.length == 0);
-        vm.assume(amount != 0);
-        unchecked {
-            vm.assume(block.timestamp + minClaimHold > minClaimHold);
-        }
+        amount = uint128(bound(amount, 1, type(uint128).max));
+        minClaimHold = uint128(bound(minClaimHold, 0, type(uint128).max - block.timestamp));
         assumeNoPrecompiles(owner);
 
         // Post the bond
@@ -332,7 +322,7 @@ contract BondManager_Test is Test {
         bm.post{ value: amount }(bondId, owner, minClaimHold);
 
         // We can't claim if the block.timestamp is less than the bond expiration.
-        (, uint256 expiration, , ) = bm.bonds(bondId);
+        (, , uint256 expiration, ) = bm.bonds(bondId);
         if (expiration > block.timestamp) {
             vm.prank(owner);
             vm.expectRevert("BondManager: Bond isn't claimable yet.");
@@ -351,7 +341,7 @@ contract BondManager_Test is Test {
  * @title MockAttestationDisputeGame
  * @dev A mock dispute game for testing bond seizures.
  */
-contract MockAttestationDisputeGame is IDisputeGame {
+contract MockAttestationDisputeGame {
     GameStatus internal gameStatus;
     BondManager bm;
     Claim internal rc;
@@ -419,11 +409,11 @@ contract MockAttestationDisputeGame is IDisputeGame {
      * -------------------------------------------
      */
 
-    function createdAt() external pure override returns (Timestamp _createdAt) {
+    function createdAt() external pure returns (Timestamp _createdAt) {
         return Timestamp.wrap(uint64(0));
     }
 
-    function status() external view override returns (GameStatus _status) {
+    function status() external view returns (GameStatus _status) {
         return gameStatus;
     }
 
@@ -431,7 +421,7 @@ contract MockAttestationDisputeGame is IDisputeGame {
         return GameType.ATTESTATION;
     }
 
-    function rootClaim() external view override returns (Claim _rootClaim) {
+    function rootClaim() external view returns (Claim _rootClaim) {
         return rc;
     }
 
@@ -439,7 +429,21 @@ contract MockAttestationDisputeGame is IDisputeGame {
         return ed;
     }
 
-    function bondManager() external view override returns (IBondManager _bondManager) {
+    function gameData()
+        external
+        pure
+        returns (
+            GameType,
+            Claim,
+            bytes memory
+        )
+    {
+        assembly {
+            revert(0, 0)
+        }
+    }
+
+    function bondManager() external view returns (IBondManager _bondManager) {
         return IBondManager(address(bm));
     }
 

packages/contracts-bedrock/contracts/test/Clones.t.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import "forge-std/Test.sol";
+
+import { ClonesWithImmutableArgs } from "@cwia/ClonesWithImmutableArgs.sol";
+
+import { Clone } from "../libraries/Clone.sol";
+
+contract ExampleClone is Clone {
+    uint256 argOffset;
+
+    constructor(uint256 _argOffset) {
+        argOffset = _argOffset;
+    }
+
+    function addressArg() public view returns (address) {
+        return _getArgAddress(argOffset);
+    }
+
+    function uintArg() public view returns (uint256) {
+        return _getArgUint256(argOffset);
+    }
+
+    function fixedBytesArg() public view returns (bytes32) {
+        return _getArgFixedBytes(argOffset);
+    }
+
+    function uintArrayArg(uint64 arrLen) public view returns (uint256[] memory) {
+        return _getArgUint256Array(argOffset, arrLen);
+    }
+
+    function dynBytesArg(uint64 arrLen) public view returns (bytes memory) {
+        return _getArgDynBytes(argOffset, arrLen);
+    }
+
+    function uint64Arg() public view returns (uint64) {
+        return _getArgUint64(argOffset);
+    }
+
+    function uint8Arg() public view returns (uint8) {
+        return _getArgUint8(argOffset);
+    }
+}
+
+contract ExampleCloneFactory {
+    using ClonesWithImmutableArgs for address;
+
+    ExampleClone public implementation;
+
+    constructor(ExampleClone implementation_) {
+        implementation = implementation_;
+    }
+
+    function createAddressClone(address arg) external returns (ExampleClone clone) {
+        bytes memory data = abi.encodePacked(arg);
+        clone = ExampleClone(address(implementation).clone(data));
+    }
+
+    function createUintClone(uint256 arg) external returns (ExampleClone clone) {
+        bytes memory data = abi.encodePacked(arg);
+        clone = ExampleClone(address(implementation).clone(data));
+    }
+
+    function createFixedBytesClone(bytes32 arg) external returns (ExampleClone clone) {
+        bytes memory data = abi.encodePacked(arg);
+        clone = ExampleClone(address(implementation).clone(data));
+    }
+
+    function createUintArrayClone(uint256[] memory arg) external returns (ExampleClone clone) {
+        bytes memory data = abi.encodePacked(arg);
+        clone = ExampleClone(address(implementation).clone(data));
+    }
+
+    function createDynBytesClone(bytes memory arg) external returns (ExampleClone clone) {
+        bytes memory data = abi.encodePacked(arg);
+        clone = ExampleClone(address(implementation).clone(data));
+    }
+
+    function createUint64Clone(uint64 arg) external returns (ExampleClone clone) {
+        bytes memory data = abi.encodePacked(arg);
+        clone = ExampleClone(address(implementation).clone(data));
+    }
+
+    function createUint8Clone(uint8 arg) external returns (ExampleClone clone) {
+        bytes memory data = abi.encodePacked(arg);
+        clone = ExampleClone(address(implementation).clone(data));
+    }
+
+    function createClone(bytes memory randomCalldata) external returns (ExampleClone clone) {
+        clone = ExampleClone(address(implementation).clone(randomCalldata));
+    }
+}
+
+contract Clones_Test is Test {
+    function testFuzz_clone_addressArg_succeeds(uint256 argOffset, address param) public {
+        ExampleClone implementation = new ExampleClone(argOffset);
+        ExampleCloneFactory factory = new ExampleCloneFactory(implementation);
+        ExampleClone clone = factory.createAddressClone(param);
+        address fetched = clone.addressArg();
+        assertEq(fetched, param);
+    }
+
+    function testFuzz_clone_uintArg_succeeds(uint256 argOffset, uint256 param) public {
+        ExampleClone implementation = new ExampleClone(argOffset);
+        ExampleCloneFactory factory = new ExampleCloneFactory(implementation);
+        ExampleClone clone = factory.createUintClone(param);
+        uint256 fetched = clone.uintArg();
+        assertEq(fetched, param);
+    }
+
+    function testFuzz_clone_fixedBytesArg_succeeds(uint256 argOffset, bytes32 param) public {
+        ExampleClone implementation = new ExampleClone(argOffset);
+        ExampleCloneFactory factory = new ExampleCloneFactory(implementation);
+        ExampleClone clone = factory.createFixedBytesClone(param);
+        bytes32 fetched = clone.fixedBytesArg();
+        assertEq(fetched, param);
+    }
+
+    function testFuzz_clone_uintArrayArg_succeeds(uint256 argOffset, uint256[] memory param)
+        public
+    {
+        ExampleClone implementation = new ExampleClone(argOffset);
+        ExampleCloneFactory factory = new ExampleCloneFactory(implementation);
+        ExampleClone clone = factory.createUintArrayClone(param);
+        uint256[] memory fetched = clone.uintArrayArg(uint64(param.length));
+        assertEq(fetched, param);
+    }
+
+    function testFuzz_clone_dynBytesArg_succeeds(uint256 argOffset, bytes memory param) public {
+        ExampleClone implementation = new ExampleClone(argOffset);
+        ExampleCloneFactory factory = new ExampleCloneFactory(implementation);
+        ExampleClone clone = factory.createDynBytesClone(param);
+        bytes memory fetched = clone.dynBytesArg(uint64(param.length));
+        assertEq(fetched, param);
+    }
+
+    function testFuzz_clone_uint64Arg_succeeds(uint256 argOffset, uint64 param) public {
+        ExampleClone implementation = new ExampleClone(argOffset);
+        ExampleCloneFactory factory = new ExampleCloneFactory(implementation);
+        ExampleClone clone = factory.createUint64Clone(param);
+        uint64 fetched = clone.uint64Arg();
+        assertEq(fetched, param);
+    }
+
+    function testFuzz_clone_uint8Arg_succeeds(uint256 argOffset, uint8 param) public {
+        ExampleClone implementation = new ExampleClone(argOffset);
+        ExampleCloneFactory factory = new ExampleCloneFactory(implementation);
+        ExampleClone clone = factory.createUint8Clone(param);
+        uint8 fetched = clone.uint8Arg();
+        assertEq(fetched, param);
+    }
+}

packages/contracts-bedrock/contracts/test/DisputeGameFactory.t.sol

@@ -6,7 +6,7 @@ import "../libraries/DisputeErrors.sol";
 
 import { Test } from "forge-std/Test.sol";
 import { DisputeGameFactory } from "../dispute/DisputeGameFactory.sol";
-import { IDisputeGame } from "../dispute/IDisputeGame.sol";
+import { IDisputeGame } from "../dispute/interfaces/IDisputeGame.sol";
 
 contract DisputeGameFactory_Test is Test {
     DisputeGameFactory factory;

packages/contracts-bedrock/scripts/storage-snapshot.sh

@@ -31,6 +31,8 @@ contracts=(
   contracts/legacy/L1ChugSplashProxy.sol:L1ChugSplashProxy
   contracts/universal/OptimismMintableERC20.sol:OptimismMintableERC20
   contracts/universal/OptimismMintableERC20Factory.sol:OptimismMintableERC20Factory
+  contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory
+  contracts/dispute/BondManager.sol:BondManager
 )
 
 dir=$(dirname "$0")