op-program: Boot program using output root

The output root replaces the L2 head hash at boot as the agreed upon point to
run the fault proof program. The L2 head is still necessary for
derivation but is redundant as it's contained in the l2 output.

op-e2e/system_fpp_test.go

@@ -86,7 +86,10 @@ func testVerifyL2OutputRootEmptyBlock(t *testing.T, detached bool) {
 	require.NoError(t, waitForSafeHead(ctx, receipt.BlockNumber.Uint64(), rollupClient))
 
 	t.Logf("Capture current L2 head as agreed starting point. l2Head=%x l2BlockNumber=%v", receipt.BlockHash, receipt.BlockNumber)
-	l2Head := receipt.BlockHash
+	agreedL2Output, err := rollupClient.OutputAtBlock(ctx, receipt.BlockNumber.Uint64())
+	require.NoError(t, err, "could not retrieve l2 agreed block")
+	l2Head := agreedL2Output.BlockRef.Hash
+	l2OutputRoot := agreedL2Output.OutputRoot
 
 	t.Log("=====Stopping batch submitter=====")
 	err = sys.BatchSubmitter.Stop(ctx)
@@ -136,6 +139,7 @@ func testVerifyL2OutputRootEmptyBlock(t *testing.T, detached bool) {
 	testFaultProofProgramScenario(t, ctx, sys, &FaultProofProgramTestScenario{
 		L1Head:             l1Head,
 		L2Head:             l2Head,
+		L2OutputRoot:       common.Hash(l2OutputRoot),
 		L2Claim:            common.Hash(l2Claim),
 		L2ClaimBlockNumber: l2ClaimBlockNumber,
 		Detached:           detached,
@@ -181,9 +185,12 @@ func testVerifyL2OutputRoot(t *testing.T, detached bool) {
 	})
 
 	t.Log("Capture current L2 head as agreed starting point")
-	l2AgreedBlock, err := l2Seq.BlockByNumber(ctx, nil)
+	latestBlock, err := l2Seq.BlockByNumber(ctx, nil)
+	require.NoError(t, err)
+	agreedL2Output, err := rollupClient.OutputAtBlock(ctx, latestBlock.NumberU64())
 	require.NoError(t, err, "could not retrieve l2 agreed block")
-	l2Head := l2AgreedBlock.Hash()
+	l2Head := agreedL2Output.BlockRef.Hash
+	l2OutputRoot := agreedL2Output.OutputRoot
 
 	t.Log("Sending transactions to modify existing state, within challenged period")
 	SendDepositTx(t, cfg, l1Client, l2Seq, opts, func(l2Opts *DepositTxOpts) {
@@ -214,6 +221,7 @@ func testVerifyL2OutputRoot(t *testing.T, detached bool) {
 	testFaultProofProgramScenario(t, ctx, sys, &FaultProofProgramTestScenario{
 		L1Head:             l1Head,
 		L2Head:             l2Head,
+		L2OutputRoot:       common.Hash(l2OutputRoot),
 		L2Claim:            common.Hash(l2Claim),
 		L2ClaimBlockNumber: l2ClaimBlockNumber,
 		Detached:           detached,
@@ -223,6 +231,7 @@ func testVerifyL2OutputRoot(t *testing.T, detached bool) {
 type FaultProofProgramTestScenario struct {
 	L1Head             common.Hash
 	L2Head             common.Hash
+	L2OutputRoot       common.Hash
 	L2Claim            common.Hash
 	L2ClaimBlockNumber uint64
 	Detached           bool
@@ -231,7 +240,7 @@ type FaultProofProgramTestScenario struct {
 // testFaultProofProgramScenario runs the fault proof program in several contexts, given a test scenario.
 func testFaultProofProgramScenario(t *testing.T, ctx context.Context, sys *System, s *FaultProofProgramTestScenario) {
 	preimageDir := t.TempDir()
-	fppConfig := oppconf.NewConfig(sys.RollupConfig, sys.L2GenesisCfg.Config, s.L1Head, s.L2Head, common.Hash(s.L2Claim), s.L2ClaimBlockNumber)
+	fppConfig := oppconf.NewConfig(sys.RollupConfig, sys.L2GenesisCfg.Config, s.L1Head, s.L2Head, s.L2OutputRoot, common.Hash(s.L2Claim), s.L2ClaimBlockNumber)
 	fppConfig.L1URL = sys.NodeEndpoint("l1")
 	fppConfig.L2URL = sys.NodeEndpoint("sequencer")
 	fppConfig.DataDir = preimageDir

op-node/eth/output.go

 package eth
 
 import (
+	"errors"
+
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 )
 
 type OutputResponse struct {
@@ -12,3 +15,70 @@ type OutputResponse struct {
 	StateRoot             common.Hash `json:"stateRoot"`
 	Status                *SyncStatus `json:"syncStatus"`
 }
+
+var (
+	ErrInvalidOutput        = errors.New("invalid output")
+	ErrInvalidOutputVersion = errors.New("invalid output version")
+
+	OutputVersionV0 = Bytes32{}
+)
+
+type Output interface {
+	// Version returns the version of the L2 output
+	Version() Bytes32
+
+	// Marshal a L2 output into a byte slice for hashing
+	Marshal() []byte
+}
+
+type OutputV0 struct {
+	StateRoot                Bytes32
+	MessagePasserStorageRoot Bytes32
+	BlockHash                common.Hash
+}
+
+func (o *OutputV0) Version() Bytes32 {
+	return OutputVersionV0
+}
+
+func (o *OutputV0) Marshal() []byte {
+	var buf [128]byte
+	version := o.Version()
+	copy(buf[:32], version[:])
+	copy(buf[32:], o.StateRoot[:])
+	copy(buf[64:], o.MessagePasserStorageRoot[:])
+	copy(buf[96:], o.BlockHash[:])
+	return buf[:]
+}
+
+// OutputRoot returns the keccak256 hash of the marshaled L2 output
+func OutputRoot(output Output) Bytes32 {
+	marshaled := output.Marshal()
+	return Bytes32(crypto.Keccak256Hash(marshaled))
+}
+
+func UnmarshalOutput(data []byte) (Output, error) {
+	if len(data) < 32 {
+		return nil, ErrInvalidOutput
+	}
+	var ver Bytes32
+	copy(ver[:], data[:32])
+	switch ver {
+	case OutputVersionV0:
+		return unmarshalOutputV0(data)
+	default:
+		return nil, ErrInvalidOutputVersion
+	}
+}
+
+func unmarshalOutputV0(data []byte) (*OutputV0, error) {
+	if len(data) < 128 {
+		return nil, ErrInvalidOutput
+	}
+	var output OutputV0
+	// data[:32] is the version
+	copy(output.StateRoot[:], data[32:64])
+	copy(output.MessagePasserStorageRoot[:], data[64:96])
+	copy(output.BlockHash[:], data[96:128])
+	return &output, nil
+}

op-node/eth/output_test.go

+package eth
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutputV0Codec(t *testing.T) {
+	output := OutputV0{
+		StateRoot:                Bytes32{1, 2, 3},
+		MessagePasserStorageRoot: Bytes32{4, 5, 6},
+		BlockHash:                common.Hash{7, 8, 9},
+	}
+	marshaled := output.Marshal()
+	unmarshaled, err := UnmarshalOutput(marshaled)
+	require.NoError(t, err)
+	unmarshaledV0 := unmarshaled.(*OutputV0)
+	require.Equal(t, output, *unmarshaledV0)
+
+	_, err = UnmarshalOutput([]byte{0: 0xA, 32: 0xA})
+	require.ErrorIs(t, err, ErrInvalidOutputVersion)
+	_, err = UnmarshalOutput([]byte{64: 0xA})
+	require.ErrorIs(t, err, ErrInvalidOutput)
+}

op-node/rollup/output_root.go

@@ -5,32 +5,33 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
-	"github.com/ethereum/go-ethereum/crypto"
 )
 
-var NilProof = errors.New("Output root proof is nil")
+var ErrNilProof = errors.New("output root proof is nil")
 
 // ComputeL2OutputRoot computes the L2 output root by hashing an output root proof.
 func ComputeL2OutputRoot(proofElements *bindings.TypesOutputRootProof) (eth.Bytes32, error) {
 	if proofElements == nil {
-		return eth.Bytes32{}, NilProof
+		return eth.Bytes32{}, ErrNilProof
 	}
 
-	digest := crypto.Keccak256Hash(
-		proofElements.Version[:],
-		proofElements.StateRoot[:],
-		proofElements.MessagePasserStorageRoot[:],
-		proofElements.LatestBlockhash[:],
-	)
-	return eth.Bytes32(digest), nil
+	if proofElements.Version != [32]byte{} {
+		return eth.Bytes32{}, errors.New("unsupported output root version")
+	}
+	l2Output := eth.OutputV0{
+		StateRoot:                eth.Bytes32(proofElements.StateRoot),
+		MessagePasserStorageRoot: proofElements.MessagePasserStorageRoot,
+		BlockHash:                proofElements.LatestBlockhash,
+	}
+	return eth.OutputRoot(&l2Output), nil
 }
 
 func ComputeL2OutputRootV0(block eth.BlockInfo, storageRoot [32]byte) (eth.Bytes32, error) {
-	var l2OutputRootVersion eth.Bytes32 // it's zero for now
-	return ComputeL2OutputRoot(&bindings.TypesOutputRootProof{
-		Version:                  l2OutputRootVersion,
-		StateRoot:                block.Root(),
+	stateRoot := block.Root()
+	l2Output := eth.OutputV0{
+		StateRoot:                eth.Bytes32(stateRoot),
 		MessagePasserStorageRoot: storageRoot,
-		LatestBlockhash:          block.Hash(),
-	})
+		BlockHash:                block.Hash(),
+	}
+	return eth.OutputRoot(&l2Output), nil
 }

op-node/sources/l1_client.go

@@ -115,3 +115,10 @@ func (s *L1Client) L1BlockRefByHash(ctx context.Context, hash common.Hash) (eth.
 	s.l1BlockRefsCache.Add(ref.Hash, ref)
 	return ref, nil
 }
+
+func (s *L1Client) L2OutputByRoot(ctx context.Context, l2OutputRoot common.Hash) (eth.Output, error) {
+	// TODO(inphi): Fetch Output from preset. Or directly from the oracle
+	//return s.OutputByRoot(ctx, l2OutputRoot)
+	var output eth.Output
+	return output, nil
+}

op-node/testutils/mock_l1.go

@@ -37,3 +37,12 @@ func (m *MockL1Source) L1BlockRefByHash(ctx context.Context, hash common.Hash) (
 func (m *MockL1Source) ExpectL1BlockRefByHash(hash common.Hash, ref eth.L1BlockRef, err error) {
 	m.Mock.On("L1BlockRefByHash", hash).Once().Return(ref, &err)
 }
+
+func (m *MockL1Source) L2OutputByRoot(ctx context.Context, root common.Hash) (eth.Output, error) {
+	out := m.Mock.MethodCalled("L2OutputByRoot", root)
+	return out[0].(eth.Output), *out[1].(*error)
+}
+
+func (m *MockL1Source) ExpectL2OutputByRoot(root common.Hash, output eth.Output, err error) {
+	m.Mock.On("L2OutputByRoot", root).Once().Return(output, &err)
+}

op-program/client/boot.go

@@ -12,7 +12,7 @@ import (
 
 const (
 	L1HeadLocalIndex preimage.LocalIndexKey = iota + 1
-	L2HeadLocalIndex
+	L2OutputRootLocalIndex
 	L2ClaimLocalIndex
 	L2ClaimBlockNumberLocalIndex
 	L2ChainConfigLocalIndex
@@ -21,7 +21,7 @@ const (
 
 type BootInfo struct {
 	L1Head             common.Hash
-	L2Head             common.Hash
+	L2OutputRoot       common.Hash
 	L2Claim            common.Hash
 	L2ClaimBlockNumber uint64
 	L2ChainConfig      *params.ChainConfig
@@ -42,7 +42,7 @@ func NewBootstrapClient(r oracleClient) *BootstrapClient {
 
 func (br *BootstrapClient) BootInfo() *BootInfo {
 	l1Head := common.BytesToHash(br.r.Get(L1HeadLocalIndex))
-	l2Head := common.BytesToHash(br.r.Get(L2HeadLocalIndex))
+	l2OutputRoot := common.BytesToHash(br.r.Get(L2OutputRootLocalIndex))
 	l2Claim := common.BytesToHash(br.r.Get(L2ClaimLocalIndex))
 	l2ClaimBlockNumber := binary.BigEndian.Uint64(br.r.Get(L2ClaimBlockNumberLocalIndex))
 	l2ChainConfig := new(params.ChainConfig)
@@ -58,7 +58,7 @@ func (br *BootstrapClient) BootInfo() *BootInfo {
 
 	return &BootInfo{
 		L1Head:             l1Head,
-		L2Head:             l2Head,
+		L2OutputRoot:       l2OutputRoot,
 		L2Claim:            l2Claim,
 		L2ClaimBlockNumber: l2ClaimBlockNumber,
 		L2ChainConfig:      l2ChainConfig,

op-program/client/boot_test.go

@@ -15,7 +15,7 @@ import (
 func TestBootstrapClient(t *testing.T) {
 	bootInfo := &BootInfo{
 		L1Head:             common.HexToHash("0x1111"),
-		L2Head:             common.HexToHash("0x2222"),
+		L2OutputRoot:       common.HexToHash("0x2222"),
 		L2Claim:            common.HexToHash("0x3333"),
 		L2ClaimBlockNumber: 1,
 		L2ChainConfig:      params.GoerliChainConfig,
@@ -34,8 +34,8 @@ func (o *mockBoostrapOracle) Get(key preimage.Key) []byte {
 	switch key.PreimageKey() {
 	case L1HeadLocalIndex.PreimageKey():
 		return o.b.L1Head[:]
-	case L2HeadLocalIndex.PreimageKey():
-		return o.b.L2Head[:]
+	case L2OutputRootLocalIndex.PreimageKey():
+		return o.b.L2OutputRoot[:]
 	case L2ClaimLocalIndex.PreimageKey():
 		return o.b.L2Claim[:]
 	case L2ClaimBlockNumberLocalIndex.PreimageKey():

op-program/client/l1/cache.go

@@ -12,21 +12,24 @@ const cacheSize = 2000
 
 // CachingOracle is an implementation of Oracle that delegates to another implementation, adding caching of all results
 type CachingOracle struct {
-	oracle Oracle
-	blocks *simplelru.LRU[common.Hash, eth.BlockInfo]
-	txs    *simplelru.LRU[common.Hash, types.Transactions]
-	rcpts  *simplelru.LRU[common.Hash, types.Receipts]
+	oracle  Oracle
+	blocks  *simplelru.LRU[common.Hash, eth.BlockInfo]
+	txs     *simplelru.LRU[common.Hash, types.Transactions]
+	rcpts   *simplelru.LRU[common.Hash, types.Receipts]
+	outputs *simplelru.LRU[common.Hash, eth.Output]
 }
 
 func NewCachingOracle(oracle Oracle) *CachingOracle {
 	blockLRU, _ := simplelru.NewLRU[common.Hash, eth.BlockInfo](cacheSize, nil)
 	txsLRU, _ := simplelru.NewLRU[common.Hash, types.Transactions](cacheSize, nil)
 	rcptsLRU, _ := simplelru.NewLRU[common.Hash, types.Receipts](cacheSize, nil)
+	outputsLRU, _ := simplelru.NewLRU[common.Hash, eth.Output](cacheSize, nil)
 	return &CachingOracle{
-		oracle: oracle,
-		blocks: blockLRU,
-		txs:    txsLRU,
-		rcpts:  rcptsLRU,
+		oracle:  oracle,
+		blocks:  blockLRU,
+		txs:     txsLRU,
+		rcpts:   rcptsLRU,
+		outputs: outputsLRU,
 	}
 }
 
@@ -61,3 +64,13 @@ func (o *CachingOracle) ReceiptsByBlockHash(blockHash common.Hash) (eth.BlockInf
 	o.rcpts.Add(blockHash, rcpts)
 	return block, rcpts
 }
+
+func (o *CachingOracle) L2OutputByRoot(l2OutputRoot common.Hash) eth.Output {
+	output, ok := o.outputs.Get(l2OutputRoot)
+	if ok {
+		return output
+	}
+	output = o.oracle.L2OutputByRoot(l2OutputRoot)
+	o.outputs.Add(l2OutputRoot, output)
+	return output
+}

op-program/client/l1/cache_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/testutils"
 	"github.com/ethereum-optimism/optimism/op-program/client/l1/test"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/require"
 )
 
@@ -71,3 +72,29 @@ func TestCachingOracle_ReceiptsByBlockHash(t *testing.T) {
 	require.Equal(t, eth.BlockToInfo(block), actualBlock)
 	require.EqualValues(t, rcpts, actualRcpts)
 }
+
+func TestCachingOracle_L2OutputByRoot(t *testing.T) {
+	rng := rand.New(rand.NewSource(1))
+	stub := test.NewStubOracle(t)
+	oracle := NewCachingOracle(stub)
+	block, _ := testutils.RandomBlock(rng, 3)
+
+	var storageRoot [32]byte
+	rng.Read(storageRoot[:])
+	l2Output := &eth.OutputV0{
+		StateRoot:                eth.Bytes32(block.Root()),
+		MessagePasserStorageRoot: storageRoot,
+		BlockHash:                block.Hash(),
+	}
+	l2OutputRoot := common.Hash(eth.OutputRoot(l2Output))
+
+	// Initial call retrieves from the stub
+	stub.L2Outputs[l2OutputRoot] = l2Output
+	result := oracle.L2OutputByRoot(l2OutputRoot)
+	require.Equal(t, l2Output.Marshal(), result)
+
+	// Later calls should retrieve from cache
+	delete(stub.L2Outputs, l2OutputRoot)
+	result = oracle.L2OutputByRoot(l2OutputRoot)
+	require.Equal(t, l2Output.Marshal(), result)
+}

op-program/client/l1/client.go

@@ -80,3 +80,7 @@ func (o *OracleL1Client) InfoAndTxsByHash(ctx context.Context, hash common.Hash)
 	info, txs := o.oracle.TransactionsByBlockHash(hash)
 	return info, txs, nil
 }
+
+func (o *OracleL1Client) L2OutputByRoot(ctx context.Context, root common.Hash) (eth.Output, error) {
+	return o.oracle.L2OutputByRoot(root), nil
+}

op-program/client/l1/hints.go

@@ -10,6 +10,7 @@ const (
 	HintL1BlockHeader  = "l1-block-header"
 	HintL1Transactions = "l1-transactions"
 	HintL1Receipts     = "l1-receipts"
+	HintL2Output       = "l1-l2-output"
 )
 
 type BlockHeaderHint common.Hash
@@ -35,3 +36,11 @@ var _ preimage.Hint = ReceiptsHint{}
 func (l ReceiptsHint) Hint() string {
 	return HintL1Receipts + " " + (common.Hash)(l).String()
 }
+
+type L2OutputHint common.Hash
+
+var _ preimage.Hint = L2OutputHint{}
+
+func (l L2OutputHint) Hint() string {
+	return HintL2Output + " " + (common.Hash)(l).String()
+}

op-program/client/l1/oracle.go

@@ -21,6 +21,9 @@ type Oracle interface {
 
 	// ReceiptsByBlockHash retrieves the receipts from the block with the given hash.
 	ReceiptsByBlockHash(blockHash common.Hash) (eth.BlockInfo, types.Receipts)
+
+	// L2OutputByRoot retrieves the L2 output for the given L2 output root.
+	L2OutputByRoot(l2OutputRoot common.Hash) eth.Output
 }
 
 // PreimageOracle implements Oracle using by interfacing with the pure preimage.Oracle
@@ -86,3 +89,13 @@ func (p *PreimageOracle) ReceiptsByBlockHash(blockHash common.Hash) (eth.BlockIn
 
 	return info, receipts
 }
+
+func (p *PreimageOracle) L2OutputByRoot(l2OutputRoot common.Hash) eth.Output {
+	p.hint.Hint(L2OutputHint(l2OutputRoot))
+	data := p.oracle.Get(preimage.Keccak256Key(l2OutputRoot))
+	output, err := eth.UnmarshalOutput(data)
+	if err != nil {
+		panic(fmt.Errorf("invalidd L2 output data for root %s: %w", l2OutputRoot, err))
+	}
+	return output
+}

op-program/client/l1/test/stub_oracle.go

@@ -19,14 +19,18 @@ type StubOracle struct {
 
 	// Rcpts maps Block hash to receipts
 	Rcpts map[common.Hash]types.Receipts
+
+	// L2Outputs maps L2 output roots to L2 outputs
+	L2Outputs map[common.Hash]eth.Output
 }
 
 func NewStubOracle(t *testing.T) *StubOracle {
 	return &StubOracle{
-		t:      t,
-		Blocks: make(map[common.Hash]eth.BlockInfo),
-		Txs:    make(map[common.Hash]types.Transactions),
-		Rcpts:  make(map[common.Hash]types.Receipts),
+		t:         t,
+		Blocks:    make(map[common.Hash]eth.BlockInfo),
+		Txs:       make(map[common.Hash]types.Transactions),
+		Rcpts:     make(map[common.Hash]types.Receipts),
+		L2Outputs: make(map[common.Hash]eth.Output),
 	}
 }
 func (o StubOracle) HeaderByBlockHash(blockHash common.Hash) eth.BlockInfo {
@@ -52,3 +56,11 @@ func (o StubOracle) ReceiptsByBlockHash(blockHash common.Hash) (eth.BlockInfo, t
 	}
 	return o.HeaderByBlockHash(blockHash), rcpts
 }
+
+func (o StubOracle) L2OutputByRoot(l2OutputRoot common.Hash) eth.Output {
+	output, ok := o.L2Outputs[l2OutputRoot]
+	if !ok {
+		o.t.Fatalf("unknown output %s", l2OutputRoot)
+	}
+	return output
+}

op-program/client/program.go

@@ -53,7 +53,7 @@ func RunProgram(logger log.Logger, preimageOracle io.ReadWriter, preimageHinter
 		bootInfo.RollupConfig,
 		bootInfo.L2ChainConfig,
 		bootInfo.L1Head,
-		bootInfo.L2Head,
+		bootInfo.L2OutputRoot,
 		bootInfo.L2Claim,
 		bootInfo.L2ClaimBlockNumber,
 		l1PreimageOracle,
@@ -62,8 +62,17 @@ func RunProgram(logger log.Logger, preimageOracle io.ReadWriter, preimageHinter
 }
 
 // runDerivation executes the L2 state transition, given a minimal interface to retrieve data.
-func runDerivation(logger log.Logger, cfg *rollup.Config, l2Cfg *params.ChainConfig, l1Head common.Hash, l2Head common.Hash, l2Claim common.Hash, l2ClaimBlockNum uint64, l1Oracle l1.Oracle, l2Oracle l2.Oracle) error {
+func runDerivation(logger log.Logger, cfg *rollup.Config, l2Cfg *params.ChainConfig, l1Head common.Hash, l2OutputRoot common.Hash, l2Claim common.Hash, l2ClaimBlockNum uint64, l1Oracle l1.Oracle, l2Oracle l2.Oracle) error {
 	l1Source := l1.NewOracleL1Client(logger, l1Oracle, l1Head)
+	output, err := l1Source.L2OutputByRoot(context.Background(), l2OutputRoot)
+	if err != nil {
+		return fmt.Errorf("failed to find L2 output for %s: %w", l2OutputRoot, err)
+	}
+	outputV0, ok := output.(*eth.OutputV0)
+	if !ok {
+		return fmt.Errorf("unsupported L2 output version: %d", output.Version())
+	}
+	l2Head := outputV0.BlockHash
 	engineBackend, err := l2.NewOracleBackedL2Chain(logger, l2Oracle, l2Cfg, l2Head)
 	if err != nil {
 		return fmt.Errorf("failed to create oracle-backed L2 chain: %w", err)

op-program/host/cmd/main_test.go

@@ -20,10 +20,12 @@ var (
 	l1HeadValue        = common.HexToHash("0x111111").Hex()
 	l2HeadValue        = common.HexToHash("0x222222").Hex()
 	l2ClaimValue       = common.HexToHash("0x333333").Hex()
+	l2OutputRoot       = common.HexToHash("0x444444").Hex()
 	l2ClaimBlockNumber = uint64(1203)
 	// Note: This is actually the L1 goerli genesis config. Just using it as an arbitrary, valid genesis config
-	l2Genesis       = core.DefaultGoerliGenesisBlock()
-	l2GenesisConfig = l2Genesis.Config
+	l2Genesis             = core.DefaultGoerliGenesisBlock()
+	l2GenesisConfig       = l2Genesis.Config
+	l2OutputOracleAddress = common.HexToAddress("0x1234567890123456789012345678901234567890").Hex()
 )
 
 func TestLogLevel(t *testing.T) {
@@ -48,6 +50,7 @@ func TestDefaultCLIOptionsMatchDefaultConfig(t *testing.T) {
 		config.OPGoerliChainConfig,
 		common.HexToHash(l1HeadValue),
 		common.HexToHash(l2HeadValue),
+		common.HexToHash(l2OutputRoot),
 		common.HexToHash(l2ClaimValue),
 		l2ClaimBlockNumber)
 	require.Equal(t, defaultCfg, cfg)
@@ -121,14 +124,14 @@ func TestL2Genesis(t *testing.T) {
 	})
 }
 
-func TestL2Head(t *testing.T) {
+func TestL2OutputRoot(t *testing.T) {
 	t.Run("Required", func(t *testing.T) {
-		verifyArgsInvalid(t, "flag l2.head is required", addRequiredArgsExcept("--l2.head"))
+		verifyArgsInvalid(t, "flag l2.outputroot is required", addRequiredArgsExcept("--l2.head"))
 	})
 
 	t.Run("Valid", func(t *testing.T) {
-		cfg := configForArgs(t, replaceRequiredArg("--l2.head", l2HeadValue))
-		require.Equal(t, common.HexToHash(l2HeadValue), cfg.L2Head)
+		cfg := configForArgs(t, replaceRequiredArg("--l2.outputroot", l2HeadValue))
+		require.Equal(t, common.HexToHash(l2HeadValue), cfg.L2OutputRoot)
 	})
 
 	t.Run("Invalid", func(t *testing.T) {

op-program/host/config/config.go

@@ -22,6 +22,7 @@ var (
 	ErrMissingL2Genesis    = errors.New("missing l2 genesis")
 	ErrInvalidL1Head       = errors.New("invalid l1 head")
 	ErrInvalidL2Head       = errors.New("invalid l2 head")
+	ErrInvalidL2OutputRoot = errors.New("invalid l2 output root")
 	ErrL1AndL2Inconsistent = errors.New("l1 and l2 options must be specified together or both omitted")
 	ErrInvalidL2Claim      = errors.New("invalid l2 claim")
 	ErrInvalidL2ClaimBlock = errors.New("invalid l2 claim block number")
@@ -41,9 +42,12 @@ type Config struct {
 	L1TrustRPC bool
 	L1RPCKind  sources.RPCProviderKind
 
-	// L2Head is the agreed L2 block to start derivation from
+	// L2Head is the l2 block hash contained in the L2 Output referenced by the L2OutputRoot
+	// TODO(inphi): This can be made optional with hardcoded rollup configs and output oracle addresses
 	L2Head common.Hash
-	L2URL  string
+	// L2OutputRoot is the agreed L2 output root to start derivation from
+	L2OutputRoot common.Hash
+	L2URL        string
 	// L2Claim is the claimed L2 output root to verify
 	L2Claim common.Hash
 	// L2ClaimBlockNumber is the block number the claimed L2 output root is from
@@ -70,8 +74,8 @@ func (c *Config) Check() error {
 	if c.L1Head == (common.Hash{}) {
 		return ErrInvalidL1Head
 	}
-	if c.L2Head == (common.Hash{}) {
-		return ErrInvalidL2Head
+	if c.L2OutputRoot == (common.Hash{}) {
+		return ErrInvalidL2OutputRoot
 	}
 	if c.L2Claim == (common.Hash{}) {
 		return ErrInvalidL2Claim
@@ -99,12 +103,21 @@ func (c *Config) FetchingEnabled() bool {
 }
 
 // NewConfig creates a Config with all optional values set to the CLI default value
-func NewConfig(rollupCfg *rollup.Config, l2Genesis *params.ChainConfig, l1Head common.Hash, l2Head common.Hash, l2Claim common.Hash, l2ClaimBlockNum uint64) *Config {
+func NewConfig(
+	rollupCfg *rollup.Config,
+	l2Genesis *params.ChainConfig,
+	l1Head common.Hash,
+	l2Head common.Hash,
+	l2OutputRoot common.Hash,
+	l2Claim common.Hash,
+	l2ClaimBlockNum uint64,
+) *Config {
 	return &Config{
 		Rollup:             rollupCfg,
 		L2ChainConfig:      l2Genesis,
 		L1Head:             l1Head,
 		L2Head:             l2Head,
+		L2OutputRoot:       l2OutputRoot,
 		L2Claim:            l2Claim,
 		L2ClaimBlockNumber: l2ClaimBlockNum,
 		L1RPCKind:          sources.RPCKindBasic,
@@ -123,6 +136,10 @@ func NewConfigFromCLI(log log.Logger, ctx *cli.Context) (*Config, error) {
 	if l2Head == (common.Hash{}) {
 		return nil, ErrInvalidL2Head
 	}
+	l2OutputRoot := common.HexToHash(ctx.String(flags.L2Head.Name))
+	if l2OutputRoot == (common.Hash{}) {
+		return nil, ErrInvalidL2OutputRoot
+	}
 	l2Claim := common.HexToHash(ctx.String(flags.L2Claim.Name))
 	if l2Claim == (common.Hash{}) {
 		return nil, ErrInvalidL2Claim
@@ -152,6 +169,7 @@ func NewConfigFromCLI(log log.Logger, ctx *cli.Context) (*Config, error) {
 		L2URL:              ctx.String(flags.L2NodeAddr.Name),
 		L2ChainConfig:      l2ChainConfig,
 		L2Head:             l2Head,
+		L2OutputRoot:       l2OutputRoot,
 		L2Claim:            l2Claim,
 		L2ClaimBlockNumber: l2ClaimBlockNum,
 		L1Head:             l1Head,

op-program/host/config/config_test.go

@@ -16,6 +16,7 @@ var (
 	validL1Head          = common.Hash{0xaa}
 	validL2Head          = common.Hash{0xbb}
 	validL2Claim         = common.Hash{0xcc}
+	validL2OutputRoot    = common.Hash{0xdd}
 	validL2ClaimBlockNum = uint64(15)
 )
 
@@ -151,7 +152,7 @@ func TestRejectExecAndServerMode(t *testing.T) {
 }
 
 func validConfig() *Config {
-	cfg := NewConfig(validRollupConfig, validL2Genesis, validL1Head, validL2Head, validL2Claim, validL2ClaimBlockNum)
+	cfg := NewConfig(validRollupConfig, validL2Genesis, validL1Head, validL2Head, validL2OutputRoot, validL2Claim, validL2ClaimBlockNum)
 	cfg.DataDir = "/tmp/configTest"
 	return cfg
 }

op-program/host/flags/flags.go

@@ -50,6 +50,11 @@ var (
 		Usage:   "Hash of the agreed L2 block to start derivation from",
 		EnvVars: prefixEnvVars("L2_HEAD"),
 	}
+	L2OutputRoot = &cli.StringFlag{
+		Name:    "l2.outputroot",
+		Usage:   "L2 Output Root at l2.head",
+		EnvVars: prefixEnvVars("L2_OUTPUT_ROOT"),
+	}
 	L2Claim = &cli.StringFlag{
 		Name:    "l2.claim",
 		Usage:   "Claimed L2 output root to validate",
@@ -103,6 +108,7 @@ var Flags []cli.Flag
 var requiredFlags = []cli.Flag{
 	L1Head,
 	L2Head,
+	L2OutputRoot,
 	L2Claim,
 	L2BlockNumber,
 }

op-program/host/host_test.go

@@ -23,7 +23,8 @@ func TestServerMode(t *testing.T) {
 	dir := t.TempDir()
 
 	l1Head := common.Hash{0x11}
-	cfg := config.NewConfig(&chaincfg.Goerli, config.OPGoerliChainConfig, l1Head, common.Hash{0x22}, common.Hash{0x33}, 1000)
+	l2OutputRoot := common.Hash{0x33}
+	cfg := config.NewConfig(&chaincfg.Goerli, config.OPGoerliChainConfig, l1Head, common.Hash{0x22}, l2OutputRoot, common.Hash{0x44}, 1000)
 	cfg.DataDir = dir
 	cfg.ServerMode = true
 
@@ -43,7 +44,8 @@ func TestServerMode(t *testing.T) {
 	hClient := preimage.NewHintWriter(hintClient)
 	l1PreimageOracle := l1.NewPreimageOracle(pClient, hClient)
 
-	require.Equal(t, l1Head.Bytes(), pClient.Get(client.L1HeadLocalIndex), "Should get preimages")
+	require.Equal(t, l1Head.Bytes(), pClient.Get(client.L1HeadLocalIndex), "Should get l1 head preimages")
+	require.Equal(t, l2OutputRoot.Bytes(), pClient.Get(client.L2OutputRootLocalIndex), "Should get l2 output root preimages")
 
 	// Should exit when a preimage is unavailable
 	require.Panics(t, func() {

op-program/host/kvstore/local.go

@@ -19,7 +19,7 @@ func NewLocalPreimageSource(config *config.Config) *LocalPreimageSource {
 
 var (
 	l1HeadKey             = client.L1HeadLocalIndex.PreimageKey()
-	l2HeadKey             = client.L2HeadLocalIndex.PreimageKey()
+	l2OutputRootKey       = client.L2OutputRootLocalIndex.PreimageKey()
 	l2ClaimKey            = client.L2ClaimLocalIndex.PreimageKey()
 	l2ClaimBlockNumberKey = client.L2ClaimBlockNumberLocalIndex.PreimageKey()
 	l2ChainConfigKey      = client.L2ChainConfigLocalIndex.PreimageKey()
@@ -30,8 +30,8 @@ func (s *LocalPreimageSource) Get(key common.Hash) ([]byte, error) {
 	switch [32]byte(key) {
 	case l1HeadKey:
 		return s.config.L1Head.Bytes(), nil
-	case l2HeadKey:
-		return s.config.L2Head.Bytes(), nil
+	case l2OutputRootKey:
+		return s.config.L2OutputRoot.Bytes(), nil
 	case l2ClaimKey:
 		return s.config.L2Claim.Bytes(), nil
 	case l2ClaimBlockNumberKey:

op-program/host/kvstore/local_test.go

@@ -17,7 +17,7 @@ func TestLocalPreimageSource(t *testing.T) {
 	cfg := &config.Config{
 		Rollup:             &chaincfg.Goerli,
 		L1Head:             common.HexToHash("0x1111"),
-		L2Head:             common.HexToHash("0x2222"),
+		L2OutputRoot:       common.HexToHash("0x2222"),
 		L2Claim:            common.HexToHash("0x3333"),
 		L2ClaimBlockNumber: 1234,
 		L2ChainConfig:      params.GoerliChainConfig,
@@ -29,7 +29,7 @@ func TestLocalPreimageSource(t *testing.T) {
 		expected []byte
 	}{
 		{"L1Head", l1HeadKey, cfg.L1Head.Bytes()},
-		{"L2Head", l2HeadKey, cfg.L2Head.Bytes()},
+		{"L2OutputRoot", l2OutputRootKey, cfg.L2OutputRoot.Bytes()},
 		{"L2Claim", l2ClaimKey, cfg.L2Claim.Bytes()},
 		{"L2ClaimBlockNumber", l2ClaimBlockNumberKey, binary.BigEndian.AppendUint64(nil, cfg.L2ClaimBlockNumber)},
 		{"Rollup", rollupKey, asJson(t, cfg.Rollup)},

op-program/host/prefetcher/prefetcher.go

@@ -23,6 +23,7 @@ type L1Source interface {
 	InfoByHash(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, error)
 	InfoAndTxsByHash(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Transactions, error)
 	FetchReceipts(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Receipts, error)
+	L2OutputByRoot(ctx context.Context, l2OutputRoot common.Hash) (eth.Output, error)
 }
 
 type L2Source interface {
@@ -98,6 +99,12 @@ func (p *Prefetcher) prefetch(ctx context.Context, hint string) error {
 			return fmt.Errorf("failed to fetch L1 block %s receipts: %w", hash, err)
 		}
 		return p.storeReceipts(receipts)
+	case l1.HintL2Output:
+		output, err := p.l1Fetcher.L2OutputByRoot(ctx, hash)
+		if err != nil {
+			return fmt.Errorf("failed to fetch L2 output root %s: %w", hash, err)
+		}
+		return p.kvStore.Put(preimage.Keccak256Key(hash).PreimageKey(), output.Marshal())
 	case l2.HintL2BlockHeader:
 		header, txs, err := p.l2Fetcher.InfoAndTxsByHash(ctx, hash)
 		if err != nil {

op-program/host/prefetcher/retry.go

@@ -73,6 +73,20 @@ func (s *RetryingL1Source) FetchReceipts(ctx context.Context, blockHash common.H
 	return info, rcpts, err
 }
 
+func (s *RetryingL1Source) L2OutputByRoot(ctx context.Context, root common.Hash) (eth.Output, error) {
+	var output eth.Output
+	err := backoff.DoCtx(ctx, maxAttempts, s.strategy, func() error {
+		o, err := s.source.L2OutputByRoot(ctx, root)
+		if err != nil {
+			s.logger.Warn("Failed to fetch l2 output", "root", root, "err", err)
+			return err
+		}
+		output = o
+		return nil
+	})
+	return output, err
+}
+
 var _ L1Source = (*RetryingL1Source)(nil)
 
 type RetryingL2Source struct {

op-program/verify/cmd/goerli.go

@@ -101,6 +101,18 @@ func Run(l1RpcUrl string, l2RpcUrl string, l2OracleAddr common.Address) error {
 		return fmt.Errorf("retrieve agreed l2 block: %w", err)
 	}
 	l2Head := l2AgreedBlock.Hash()
+	agreedOutputIndex, err := outputOracle.GetL2OutputIndexAfter(callOpts, l2AgreedBlock.Number())
+	if err != nil {
+		return fmt.Errorf("failed to output index after agreed block")
+	}
+	agreedOutput, err := outputOracle.GetL2Output(callOpts, agreedOutputIndex)
+	if err != nil {
+		return fmt.Errorf("retrieve agreed output: %w", err)
+	}
+	if agreedOutput.OutputRoot == output.OutputRoot {
+		// TODO(inphi): Don't return here but keep searching preceeding blocks for a different output
+		return fmt.Errorf("agreed output is the same as the output claim")
+	}
 
 	temp, err := os.MkdirTemp("", "oracledata")
 	if err != nil {
@@ -120,6 +132,7 @@ func Run(l1RpcUrl string, l2RpcUrl string, l2OracleAddr common.Address) error {
 		"--datadir", temp,
 		"--l1.head", l1Head.Hex(),
 		"--l2.head", l2Head.Hex(),
+		"--l2.outputroot", common.Bytes2Hex(agreedOutput.OutputRoot[:]),
 		"--l2.claim", l2Claim.Hex(),
 		"--l2.blocknumber", l2BlockNumber.String(),
 	}