Merge pull request #5423 from ethereum-optimism/aj/fpp-caching

op-program: Implement caching for the oracle.

op-program/client/l1/cache.go

+package l1
+
+import (
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/hashicorp/golang-lru/v2/simplelru"
+)
+
+// Cache size is quite high as retrieving data from the pre-image oracle can be quite expensive
+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]
+}
+
+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)
+	return &CachingOracle{
+		oracle: oracle,
+		blocks: blockLRU,
+		txs:    txsLRU,
+		rcpts:  rcptsLRU,
+	}
+}
+
+func (o *CachingOracle) HeaderByBlockHash(blockHash common.Hash) eth.BlockInfo {
+	block, ok := o.blocks.Get(blockHash)
+	if ok {
+		return block
+	}
+	block = o.oracle.HeaderByBlockHash(blockHash)
+	o.blocks.Add(blockHash, block)
+	return block
+}
+
+func (o *CachingOracle) TransactionsByBlockHash(blockHash common.Hash) (eth.BlockInfo, types.Transactions) {
+	txs, ok := o.txs.Get(blockHash)
+	if ok {
+		return o.HeaderByBlockHash(blockHash), txs
+	}
+	block, txs := o.oracle.TransactionsByBlockHash(blockHash)
+	o.blocks.Add(blockHash, block)
+	o.txs.Add(blockHash, txs)
+	return block, txs
+}
+
+func (o *CachingOracle) ReceiptsByBlockHash(blockHash common.Hash) (eth.BlockInfo, types.Receipts) {
+	rcpts, ok := o.rcpts.Get(blockHash)
+	if ok {
+		return o.HeaderByBlockHash(blockHash), rcpts
+	}
+	block, rcpts := o.oracle.ReceiptsByBlockHash(blockHash)
+	o.blocks.Add(blockHash, block)
+	o.rcpts.Add(blockHash, rcpts)
+	return block, rcpts
+}

op-program/client/l1/cache_test.go

+package l1
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-node/testutils"
+	"github.com/stretchr/testify/require"
+)
+
+// Should implement Oracle
+var _ Oracle = (*CachingOracle)(nil)
+
+func TestCachingOracle_HeaderByBlockHash(t *testing.T) {
+	rng := rand.New(rand.NewSource(1))
+	stub := newStubOracle(t)
+	oracle := NewCachingOracle(stub)
+	block := testutils.RandomBlockInfo(rng)
+
+	// Initial call retrieves from the stub
+	stub.blocks[block.Hash()] = block
+	result := oracle.HeaderByBlockHash(block.Hash())
+	require.Equal(t, block, result)
+
+	// Later calls should retrieve from cache
+	delete(stub.blocks, block.Hash())
+	result = oracle.HeaderByBlockHash(block.Hash())
+	require.Equal(t, block, result)
+}
+
+func TestCachingOracle_TransactionsByBlockHash(t *testing.T) {
+	rng := rand.New(rand.NewSource(1))
+	stub := newStubOracle(t)
+	oracle := NewCachingOracle(stub)
+	block, _ := testutils.RandomBlock(rng, 3)
+
+	// Initial call retrieves from the stub
+	stub.blocks[block.Hash()] = block
+	stub.txs[block.Hash()] = block.Transactions()
+	actualBlock, actualTxs := oracle.TransactionsByBlockHash(block.Hash())
+	require.Equal(t, block, actualBlock)
+	require.Equal(t, block.Transactions(), actualTxs)
+
+	// Later calls should retrieve from cache
+	delete(stub.blocks, block.Hash())
+	delete(stub.txs, block.Hash())
+	actualBlock, actualTxs = oracle.TransactionsByBlockHash(block.Hash())
+	require.Equal(t, block, actualBlock)
+	require.Equal(t, block.Transactions(), actualTxs)
+}
+
+func TestCachingOracle_ReceiptsByBlockHash(t *testing.T) {
+	rng := rand.New(rand.NewSource(1))
+	stub := newStubOracle(t)
+	oracle := NewCachingOracle(stub)
+	block, rcpts := testutils.RandomBlock(rng, 3)
+
+	// Initial call retrieves from the stub
+	stub.blocks[block.Hash()] = block
+	stub.rcpts[block.Hash()] = rcpts
+	actualBlock, actualRcpts := oracle.ReceiptsByBlockHash(block.Hash())
+	require.Equal(t, block, actualBlock)
+	require.EqualValues(t, rcpts, actualRcpts)
+
+	// Later calls should retrieve from cache
+	delete(stub.blocks, block.Hash())
+	delete(stub.rcpts, block.Hash())
+	actualBlock, actualRcpts = oracle.ReceiptsByBlockHash(block.Hash())
+	require.Equal(t, block, actualBlock)
+	require.EqualValues(t, rcpts, actualRcpts)
+}

op-program/client/l1/client_test.go

@@ -145,54 +145,12 @@ func TestL1BlockRefByNumber(t *testing.T) {
 }
 
 func newClient(t *testing.T) (*OracleL1Client, *stubOracle) {
-	stub := &stubOracle{
-		t:      t,
-		blocks: make(map[common.Hash]eth.BlockInfo),
-		txs:    make(map[common.Hash]types.Transactions),
-		rcpts:  make(map[common.Hash]types.Receipts),
-	}
+	stub := newStubOracle(t)
 	stub.blocks[head.Hash()] = head
 	client := NewOracleL1Client(testlog.Logger(t, log.LvlDebug), stub, head.Hash())
 	return client, stub
 }
 
-type stubOracle struct {
-	t *testing.T
-
-	// blocks maps block hash to eth.BlockInfo
-	blocks map[common.Hash]eth.BlockInfo
-
-	// txs maps block hash to transactions
-	txs map[common.Hash]types.Transactions
-
-	// rcpts maps Block hash to receipts
-	rcpts map[common.Hash]types.Receipts
-}
-
-func (o stubOracle) HeaderByBlockHash(blockHash common.Hash) eth.BlockInfo {
-	info, ok := o.blocks[blockHash]
-	if !ok {
-		o.t.Fatalf("unknown block %s", blockHash)
-	}
-	return info
-}
-
-func (o stubOracle) TransactionsByBlockHash(blockHash common.Hash) (eth.BlockInfo, types.Transactions) {
-	txs, ok := o.txs[blockHash]
-	if !ok {
-		o.t.Fatalf("unknown txs %s", blockHash)
-	}
-	return o.HeaderByBlockHash(blockHash), txs
-}
-
-func (o stubOracle) ReceiptsByBlockHash(blockHash common.Hash) (eth.BlockInfo, types.Receipts) {
-	rcpts, ok := o.rcpts[blockHash]
-	if !ok {
-		o.t.Fatalf("unknown rcpts %s", blockHash)
-	}
-	return o.HeaderByBlockHash(blockHash), rcpts
-}
-
 func blockNum(num uint64) eth.BlockInfo {
 	parentNum := num - 1
 	return &testutils.MockBlockInfo{

op-program/client/l1/stub_oracle_test.go

+package l1
+
+import (
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type stubOracle struct {
+	t *testing.T
+
+	// blocks maps block hash to eth.BlockInfo
+	blocks map[common.Hash]eth.BlockInfo
+
+	// txs maps block hash to transactions
+	txs map[common.Hash]types.Transactions
+
+	// rcpts maps Block hash to receipts
+	rcpts map[common.Hash]types.Receipts
+}
+
+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),
+	}
+}
+func (o stubOracle) HeaderByBlockHash(blockHash common.Hash) eth.BlockInfo {
+	info, ok := o.blocks[blockHash]
+	if !ok {
+		o.t.Fatalf("unknown block %s", blockHash)
+	}
+	return info
+}
+
+func (o stubOracle) TransactionsByBlockHash(blockHash common.Hash) (eth.BlockInfo, types.Transactions) {
+	txs, ok := o.txs[blockHash]
+	if !ok {
+		o.t.Fatalf("unknown txs %s", blockHash)
+	}
+	return o.HeaderByBlockHash(blockHash), txs
+}
+
+func (o stubOracle) ReceiptsByBlockHash(blockHash common.Hash) (eth.BlockInfo, types.Receipts) {
+	rcpts, ok := o.rcpts[blockHash]
+	if !ok {
+		o.t.Fatalf("unknown rcpts %s", blockHash)
+	}
+	return o.HeaderByBlockHash(blockHash), rcpts
+}

op-program/client/l2/cache.go

+package l2
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/hashicorp/golang-lru/v2/simplelru"
+)
+
+const blockCacheSize = 2_000
+const nodeCacheSize = 100_000
+const codeCacheSize = 10_000
+
+type CachingOracle struct {
+	oracle Oracle
+	blocks *simplelru.LRU[common.Hash, *types.Block]
+	nodes  *simplelru.LRU[common.Hash, []byte]
+	codes  *simplelru.LRU[common.Hash, []byte]
+}
+
+func NewCachingOracle(oracle Oracle) *CachingOracle {
+	blockLRU, _ := simplelru.NewLRU[common.Hash, *types.Block](blockCacheSize, nil)
+	nodeLRU, _ := simplelru.NewLRU[common.Hash, []byte](nodeCacheSize, nil)
+	codeLRU, _ := simplelru.NewLRU[common.Hash, []byte](codeCacheSize, nil)
+	return &CachingOracle{
+		oracle: oracle,
+		blocks: blockLRU,
+		nodes:  nodeLRU,
+		codes:  codeLRU,
+	}
+}
+
+func (o *CachingOracle) NodeByHash(nodeHash common.Hash) []byte {
+	node, ok := o.nodes.Get(nodeHash)
+	if ok {
+		return node
+	}
+	node = o.oracle.NodeByHash(nodeHash)
+	o.nodes.Add(nodeHash, node)
+	return node
+}
+
+func (o *CachingOracle) CodeByHash(codeHash common.Hash) []byte {
+	code, ok := o.codes.Get(codeHash)
+	if ok {
+		return code
+	}
+	code = o.oracle.CodeByHash(codeHash)
+	o.codes.Add(codeHash, code)
+	return code
+}
+
+func (o *CachingOracle) BlockByHash(blockHash common.Hash) *types.Block {
+	block, ok := o.blocks.Get(blockHash)
+	if ok {
+		return block
+	}
+	block = o.oracle.BlockByHash(blockHash)
+	o.blocks.Add(blockHash, block)
+	return block
+}

op-program/client/l2/cache_test.go

+package l2
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-node/testutils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+// Should be an Oracle implementation
+var _ Oracle = (*CachingOracle)(nil)
+
+func TestBlockByHash(t *testing.T) {
+	stub, _ := newStubOracle(t)
+	oracle := NewCachingOracle(stub)
+
+	rng := rand.New(rand.NewSource(1))
+	block, _ := testutils.RandomBlock(rng, 1)
+
+	// Initial call retrieves from the stub
+	stub.blocks[block.Hash()] = block
+	actual := oracle.BlockByHash(block.Hash())
+	require.Equal(t, block, actual)
+
+	// Later calls should retrieve from cache
+	delete(stub.blocks, block.Hash())
+	actual = oracle.BlockByHash(block.Hash())
+	require.Equal(t, block, actual)
+}
+
+func TestNodeByHash(t *testing.T) {
+	stub, stateStub := newStubOracle(t)
+	oracle := NewCachingOracle(stub)
+
+	node := []byte{12, 3, 4}
+	hash := common.Hash{0xaa}
+
+	// Initial call retrieves from the stub
+	stateStub.data[hash] = node
+	actual := oracle.NodeByHash(hash)
+	require.Equal(t, node, actual)
+
+	// Later calls should retrieve from cache
+	delete(stateStub.data, hash)
+	actual = oracle.NodeByHash(hash)
+	require.Equal(t, node, actual)
+}
+
+func TestCodeByHash(t *testing.T) {
+	stub, stateStub := newStubOracle(t)
+	oracle := NewCachingOracle(stub)
+
+	node := []byte{12, 3, 4}
+	hash := common.Hash{0xaa}
+
+	// Initial call retrieves from the stub
+	stateStub.code[hash] = node
+	actual := oracle.CodeByHash(hash)
+	require.Equal(t, node, actual)
+
+	// Later calls should retrieve from cache
+	delete(stateStub.code, hash)
+	actual = oracle.CodeByHash(hash)
+	require.Equal(t, node, actual)
+}

op-program/client/l2/db_test.go

@@ -194,51 +194,3 @@ func assertStateDataAvailable(t *testing.T, db ethdb.KeyValueStore, l2Genesis *c
 	require.Nil(t, statedb.GetCode(unknownAccount), "unset account code")
 	require.Equal(t, common.Hash{}, statedb.GetCodeHash(unknownAccount), "unset account code hash")
 }
-
-func newStubStateOracle(t *testing.T) *stubStateOracle {
-	return &stubStateOracle{
-		t:    t,
-		data: make(map[common.Hash][]byte),
-		code: make(map[common.Hash][]byte),
-	}
-}
-
-type stubStateOracle struct {
-	t    *testing.T
-	data map[common.Hash][]byte
-	code map[common.Hash][]byte
-}
-
-func (o *stubStateOracle) NodeByHash(nodeHash common.Hash) []byte {
-	data, ok := o.data[nodeHash]
-	if !ok {
-		o.t.Fatalf("no value for node %v", nodeHash)
-	}
-	return data
-}
-
-func (o *stubStateOracle) CodeByHash(hash common.Hash) []byte {
-	data, ok := o.code[hash]
-	if !ok {
-		o.t.Fatalf("no value for code %v", hash)
-	}
-	return data
-}
-
-// kvStateOracle loads data from a source ethdb.KeyValueStore
-type kvStateOracle struct {
-	t      *testing.T
-	source ethdb.KeyValueStore
-}
-
-func (o *kvStateOracle) NodeByHash(nodeHash common.Hash) []byte {
-	val, err := o.source.Get(nodeHash.Bytes())
-	if err != nil {
-		o.t.Fatalf("error retrieving node %v: %v", nodeHash, err)
-	}
-	return val
-}
-
-func (o *kvStateOracle) CodeByHash(hash common.Hash) []byte {
-	return rawdb.ReadCode(o.source, hash)
-}

op-program/client/l2/engine_backend_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/stretchr/testify/require"
@@ -168,7 +167,7 @@ func setupOracle(t *testing.T, blockCount int, headBlockNumber int) (*params.Cha
 	genesisBlock := l2Genesis.MustCommit(db)
 	blocks, _ := core.GenerateChain(chainCfg, genesisBlock, consensus, db, blockCount, func(i int, gen *core.BlockGen) {})
 	blocks = append([]*types.Block{genesisBlock}, blocks...)
-	oracle := newStubBlockOracle(t, blocks[:headBlockNumber+1], db)
+	oracle := newStubOracleWithBlocks(t, blocks[:headBlockNumber+1], db)
 	return chainCfg, blocks, oracle
 }
 
@@ -195,30 +194,6 @@ func createBlock(t *testing.T, chain *OracleBackedL2Chain) *types.Block {
 	return blocks[0]
 }
 
-type stubBlockOracle struct {
-	blocks map[common.Hash]*types.Block
-	kvStateOracle
-}
-
-func newStubBlockOracle(t *testing.T, chain []*types.Block, db ethdb.Database) *stubBlockOracle {
-	blocks := make(map[common.Hash]*types.Block, len(chain))
-	for _, block := range chain {
-		blocks[block.Hash()] = block
-	}
-	return &stubBlockOracle{
-		blocks:        blocks,
-		kvStateOracle: kvStateOracle{t: t, source: db},
-	}
-}
-
-func (o stubBlockOracle) BlockByHash(blockHash common.Hash) *types.Block {
-	block, ok := o.blocks[blockHash]
-	if !ok {
-		o.t.Fatalf("requested unknown block %s", blockHash)
-	}
-	return block
-}
-
 func TestEngineAPITests(t *testing.T) {
 	test.RunEngineAPITests(t, func(t *testing.T) engineapi.EngineBackend {
 		_, chain := setupOracleBackedChain(t, 0)

op-program/client/l2/stub_oracle_test.go

+package l2
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethdb"
+)
+
+type stubBlockOracle struct {
+	t      *testing.T
+	blocks map[common.Hash]*types.Block
+	StateOracle
+}
+
+func newStubOracle(t *testing.T) (*stubBlockOracle, *stubStateOracle) {
+	stateOracle := newStubStateOracle(t)
+	blockOracle := stubBlockOracle{
+		t:           t,
+		blocks:      make(map[common.Hash]*types.Block),
+		StateOracle: stateOracle,
+	}
+	return &blockOracle, stateOracle
+}
+
+func newStubOracleWithBlocks(t *testing.T, chain []*types.Block, db ethdb.Database) *stubBlockOracle {
+	blocks := make(map[common.Hash]*types.Block, len(chain))
+	for _, block := range chain {
+		blocks[block.Hash()] = block
+	}
+	return &stubBlockOracle{
+		blocks:      blocks,
+		StateOracle: &kvStateOracle{t: t, source: db},
+	}
+}
+
+func (o stubBlockOracle) BlockByHash(blockHash common.Hash) *types.Block {
+	block, ok := o.blocks[blockHash]
+	if !ok {
+		o.t.Fatalf("requested unknown block %s", blockHash)
+	}
+	return block
+}
+
+// kvStateOracle loads data from a source ethdb.KeyValueStore
+type kvStateOracle struct {
+	t      *testing.T
+	source ethdb.KeyValueStore
+}
+
+func (o *kvStateOracle) NodeByHash(nodeHash common.Hash) []byte {
+	val, err := o.source.Get(nodeHash.Bytes())
+	if err != nil {
+		o.t.Fatalf("error retrieving node %v: %v", nodeHash, err)
+	}
+	return val
+}
+
+func (o *kvStateOracle) CodeByHash(hash common.Hash) []byte {
+	return rawdb.ReadCode(o.source, hash)
+}
+
+func newStubStateOracle(t *testing.T) *stubStateOracle {
+	return &stubStateOracle{
+		t:    t,
+		data: make(map[common.Hash][]byte),
+		code: make(map[common.Hash][]byte),
+	}
+}
+
+// Stub StateOracle implementation that reads from simple maps
+type stubStateOracle struct {
+	t    *testing.T
+	data map[common.Hash][]byte
+	code map[common.Hash][]byte
+}
+
+func (o *stubStateOracle) NodeByHash(nodeHash common.Hash) []byte {
+	data, ok := o.data[nodeHash]
+	if !ok {
+		o.t.Fatalf("no value for node %v", nodeHash)
+	}
+	return data
+}
+
+func (o *stubStateOracle) CodeByHash(hash common.Hash) []byte {
+	data, ok := o.code[hash]
+	if !ok {
+		o.t.Fatalf("no value for code %v", hash)
+	}
+	return data
+}

op-program/host/l1/l1.go

@@ -21,6 +21,6 @@ func NewFetchingL1(ctx context.Context, logger log.Logger, cfg *config.Config) (
 	if err != nil {
 		return nil, err
 	}
-	oracle := NewFetchingL1Oracle(ctx, logger, source)
+	oracle := cll1.NewCachingOracle(NewFetchingL1Oracle(ctx, logger, source))
 	return cll1.NewOracleL1Client(logger, oracle, cfg.L1Head), err
 }

op-program/host/l2/l2.go

@@ -19,10 +19,11 @@ func NewFetchingEngine(ctx context.Context, logger log.Logger, cfg *config.Confi
 	if err != nil {
 		return nil, err
 	}
-	oracle, err := NewFetchingL2Oracle(ctx, logger, cfg.L2URL, cfg.L2Head)
+	fetcher, err := NewFetchingL2Oracle(ctx, logger, cfg.L2URL, cfg.L2Head)
 	if err != nil {
 		return nil, fmt.Errorf("connect l2 oracle: %w", err)
 	}
+	oracle := cll2.NewCachingOracle(fetcher)
 
 	engineBackend, err := cll2.NewOracleBackedL2Chain(logger, oracle, genesis, cfg.L2Head)
 	if err != nil {