op-e2e: Add Access Lists to interop txs

go.mod

@@ -274,7 +274,7 @@ require (
 	rsc.io/tmplfunc v0.0.3 // indirect
 )
 
-replace github.com/ethereum/go-ethereum => github.com/ethereum-optimism/op-geth v1.101503.1-rc.1
+replace github.com/ethereum/go-ethereum => github.com/ethereum-optimism/op-geth v1.101503.2-rc.1
 
 //replace github.com/ethereum/go-ethereum => ../op-geth
 

go.sum

@@ -204,10 +204,8 @@ github.com/elastic/gosigar v0.14.3 h1:xwkKwPia+hSfg9GqrCUKYdId102m9qTJIIr7egmK/u
 github.com/elastic/gosigar v0.14.3/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
 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.101503.1-rc.1 h1:jKZUJb/oFgwT/z/d+vlBsKSgrDfkblawT3WYasfiQV8=
-github.com/ethereum-optimism/op-geth v1.101503.1-rc.1/go.mod h1:QUo3fn+45vWqJWzJW+rIzRHUV7NmhhHLPdI87mAn1M8=
-github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20250307201638-7c3999db14c6 h1:EBEaI3oygl1npFpvdHghcWbKnhj2alEe4KqM2jG2XS8=
-github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20250307201638-7c3999db14c6/go.mod h1:NZ816PzLU1TLv1RdAvYAb6KWOj4Zm5aInT0YpDVml2Y=
+github.com/ethereum-optimism/op-geth v1.101503.2-rc.1 h1:a//Sc0necznugHkwS4gey4uS9qDoSk8g3TazLDVnQ/8=
+github.com/ethereum-optimism/op-geth v1.101503.2-rc.1/go.mod h1:QUo3fn+45vWqJWzJW+rIzRHUV7NmhhHLPdI87mAn1M8=
 github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20250314162817-2c60e5723c64 h1:teDhU4h4ryaE8rSBl+vJJiwKHjxdnnHPkKZ9iNr2R8k=
 github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20250314162817-2c60e5723c64/go.mod h1:NZ816PzLU1TLv1RdAvYAb6KWOj4Zm5aInT0YpDVml2Y=
 github.com/ethereum/c-kzg-4844 v1.0.0 h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA=

op-e2e/actions/interop/dsl/inbox.go

@@ -3,11 +3,16 @@ package dsl
 import (
 	"math/big"
 
+	"github.com/stretchr/testify/require"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+
 	"github.com/ethereum-optimism/optimism/op-e2e/actions/helpers"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/interop/contracts/bindings/inbox"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
 	"github.com/ethereum-optimism/optimism/op-service/predeploys"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/stretchr/testify/require"
+	stypes "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types"
 )
 
 type InboxContract struct {
@@ -84,7 +89,21 @@ func (i *InboxContract) Execute(user *DSLUser, initTx *GeneratedTransaction, arg
 		txOpts, from := user.TransactOpts(chain.ChainID.ToBig())
 		contract, err := inbox.NewInbox(predeploys.CrossL2InboxAddr, chain.SequencerEngine.EthClient())
 		require.NoError(i.t, err)
-		tx, err := contract.ValidateMessage(txOpts, ident, crypto.Keccak256Hash(payload))
+		id := stypes.Identifier{
+			Origin:      ident.Origin,
+			BlockNumber: ident.BlockNumber.Uint64(),
+			LogIndex:    uint32(ident.LogIndex.Uint64()),
+			Timestamp:   ident.Timestamp.Uint64(),
+			ChainID:     eth.ChainIDFromBig(ident.ChainId),
+		}
+		msgHash := crypto.Keccak256Hash(payload)
+		access := id.ChecksumArgs(msgHash).Access()
+		inboxAccessList := stypes.EncodeAccessList([]stypes.Access{access})
+		txOpts.AccessList = types.AccessList{types.AccessTuple{
+			Address:     predeploys.CrossL2InboxAddr,
+			StorageKeys: inboxAccessList,
+		}}
+		tx, err := contract.ValidateMessage(txOpts, ident, msgHash)
 		require.NoError(i.t, err)
 		genTx := NewGeneratedTransaction(i.t, chain, tx, from)
 		i.Transactions = append(i.Transactions, genTx)

op-e2e/actions/interop/dsl/message.go

@@ -3,6 +3,8 @@ package dsl
 import (
 	"github.com/ethereum-optimism/optimism/op-e2e/actions/helpers"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/interop/contracts/bindings/inbox"
+	"github.com/ethereum-optimism/optimism/op-service/predeploys"
+	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/stretchr/testify/require"
 )
 
@@ -54,10 +56,22 @@ func (m *Message) ActEmitDeposit(l1User *DSLUser) helpers.Action {
 	}
 }
 
+func sanityCheckAccessList(t helpers.Testing, li types.AccessList) {
+	for _, e := range li {
+		if e.Address == predeploys.CrossL2InboxAddr {
+			if len(e.StorageKeys) > 0 {
+				return
+			}
+		}
+	}
+	t.Fatal("expected executing-message entries in access-list")
+}
+
 func (m *Message) ExecuteOn(target *Chain, execOpts ...func(*ExecuteOpts)) *Message {
 	require.NotNil(m.t, m.initTx, "message must be emitted before it can be executed")
 	execAction := m.inbox.Execute(m.user, m.initTx, execOpts...)
 	m.execTx = execAction(target)
+	sanityCheckAccessList(m.t, m.execTx.tx.AccessList())
 	m.execTx.IncludeOK()
 	return m
 }
@@ -69,6 +83,7 @@ func (m *Message) ExecutePendingOn(target *Chain, pendingMessageBlockNumber uint
 	opts = append(opts, execOpts...)
 	execAction := m.inbox.Execute(m.user, nil, opts...)
 	m.execTx = execAction(target)
+	sanityCheckAccessList(m.t, m.execTx.tx.AccessList())
 	m.execTx.IncludeOK()
 	return m
 }

op-e2e/actions/interop/emitter_contract_test.go

@@ -5,21 +5,23 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/ethereum-optimism/optimism/op-e2e/actions/interop/dsl"
+	"github.com/stretchr/testify/require"
+
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/params"
-	"github.com/stretchr/testify/require"
 
 	"github.com/ethereum-optimism/optimism/op-chain-ops/devkeys"
 	"github.com/ethereum-optimism/optimism/op-e2e/actions/helpers"
+	"github.com/ethereum-optimism/optimism/op-e2e/actions/interop/dsl"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/interop/contracts/bindings/emit"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/interop/contracts/bindings/inbox"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/event"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
 	"github.com/ethereum-optimism/optimism/op-service/predeploys"
 	stypes "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types"
 )
@@ -31,7 +33,6 @@ type userWithKeys struct {
 }
 
 func TestEmitterContract(gt *testing.T) {
-	gt.Skip("temporarily broken by access-list change")
 	var (
 		is     *dsl.InteropSetup
 		actors *dsl.InteropActors
@@ -72,7 +73,14 @@ func TestEmitterContract(gt *testing.T) {
 		id := idForTx(t, emitTx, actors.ChainA)
 		contract, err := inbox.NewInbox(predeploys.CrossL2InboxAddr, actors.ChainB.SequencerEngine.EthClient())
 		require.NoError(t, err)
-		tx, err := contract.ValidateMessage(auth, id, crypto.Keccak256Hash(fakeMessage))
+		msgHash := crypto.Keccak256Hash(fakeMessage)
+		access := id.ChecksumArgs(msgHash).Access()
+		inboxAccessList := stypes.EncodeAccessList([]stypes.Access{access})
+		auth.AccessList = types.AccessList{types.AccessTuple{
+			Address:     predeploys.CrossL2InboxAddr,
+			StorageKeys: inboxAccessList,
+		}}
+		tx, err := contract.ValidateMessage(auth, identifierForBindings(id), msgHash)
 		require.NoError(t, err)
 
 		// Process the invalid message attempt and verify that only the local unsafe head progresses
@@ -128,27 +136,43 @@ func newExecuteMessageTx(t helpers.Testing, destChain *dsl.Chain, executor *user
 }
 
 // newExecuteMessageTxFromIDAndHash creates a new executing message tx for the given id and hash.
-func newExecuteMessageTxFromIDAndHash(t helpers.Testing, executor *userWithKeys, destChain *dsl.Chain, id inbox.Identifier, hash common.Hash) *types.Transaction {
+func newExecuteMessageTxFromIDAndHash(t helpers.Testing, executor *userWithKeys, destChain *dsl.Chain, id stypes.Identifier, msgHash common.Hash) *types.Transaction {
 	inboxContract, err := inbox.NewInbox(predeploys.CrossL2InboxAddr, destChain.SequencerEngine.EthClient())
 	require.NoError(t, err)
 	auth := newL2TxOpts(t, executor.secret, destChain)
-	tx, err := inboxContract.ValidateMessage(auth, id, hash)
+	access := id.ChecksumArgs(msgHash).Access()
+	inboxAccessList := stypes.EncodeAccessList([]stypes.Access{access})
+	auth.AccessList = types.AccessList{types.AccessTuple{
+		Address:     predeploys.CrossL2InboxAddr,
+		StorageKeys: inboxAccessList,
+	}}
+	tx, err := inboxContract.ValidateMessage(auth, identifierForBindings(id), msgHash)
 	require.NoError(t, err)
 	return tx
 }
 
-func idForTx(t helpers.Testing, tx *types.Transaction, srcChain *dsl.Chain) inbox.Identifier {
+func idForTx(t helpers.Testing, tx *types.Transaction, srcChain *dsl.Chain) stypes.Identifier {
 	receipt, err := srcChain.SequencerEngine.EthClient().TransactionReceipt(t.Ctx(), tx.Hash())
 	require.NoError(t, err)
 	block, err := srcChain.SequencerEngine.EthClient().BlockByNumber(t.Ctx(), receipt.BlockNumber)
 	require.NoError(t, err)
 
-	return inbox.Identifier{
+	return stypes.Identifier{
 		Origin:      *tx.To(),
-		BlockNumber: receipt.BlockNumber,
-		LogIndex:    common.Big0,
-		Timestamp:   big.NewInt(int64(block.Time())),
-		ChainId:     srcChain.RollupCfg.L2ChainID,
+		BlockNumber: receipt.BlockNumber.Uint64(),
+		LogIndex:    0,
+		Timestamp:   block.Time(),
+		ChainID:     eth.ChainIDFromBig(srcChain.RollupCfg.L2ChainID),
+	}
+}
+
+func identifierForBindings(id stypes.Identifier) inbox.Identifier {
+	return inbox.Identifier{
+		Origin:      id.Origin,
+		BlockNumber: new(big.Int).SetUint64(id.BlockNumber),
+		LogIndex:    new(big.Int).SetUint64(uint64(id.LogIndex)),
+		Timestamp:   new(big.Int).SetUint64(id.Timestamp),
+		ChainId:     id.ChainID.ToBig(),
 	}
 }
 

op-e2e/actions/interop/interop_test.go

@@ -1,7 +1,6 @@
 package interop
 
 import (
-	"math/big"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -12,12 +11,11 @@ import (
 	"github.com/ethereum-optimism/optimism/op-e2e/actions/helpers"
 	"github.com/ethereum-optimism/optimism/op-e2e/actions/interop/dsl"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/interop/contracts/bindings/emit"
-	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/interop/contracts/bindings/inbox"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/event"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/interop/managed"
 	"github.com/ethereum-optimism/optimism/op-service/eth"
-	"github.com/ethereum-optimism/optimism/op-service/predeploys"
+	stypes "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types"
 )
 
 func TestFullInterop(gt *testing.T) {
@@ -240,7 +238,6 @@ func TestFinality(gt *testing.T) {
 }
 
 func TestInteropLocalSafeInvalidation(gt *testing.T) {
-	gt.Skip("temporarily broken by access-list change")
 	t := helpers.NewDefaultTesting(gt)
 
 	is := dsl.SetupInterop(t)
@@ -252,21 +249,18 @@ func TestInteropLocalSafeInvalidation(gt *testing.T) {
 	// build L2 block on chain B with invalid executing message pointing to A.
 	fakeMessage := []byte("this message was never emitted")
 	aliceB := setupUser(t, is, actors.ChainB, 0)
-	auth := newL2TxOpts(t, aliceB.secret, actors.ChainB)
-	id := inbox.Identifier{
+	id := stypes.Identifier{
 		Origin:      common.Address{0x42},
-		BlockNumber: new(big.Int).SetUint64(genesisB.UnsafeL2.Number),
-		LogIndex:    common.Big0,
-		Timestamp:   new(big.Int).SetUint64(genesisB.UnsafeL2.Time),
-		ChainId:     actors.ChainA.RollupCfg.L2ChainID,
+		BlockNumber: genesisB.UnsafeL2.Number,
+		LogIndex:    0,
+		Timestamp:   genesisB.UnsafeL2.Time,
+		ChainID:     eth.ChainIDFromBig(actors.ChainA.RollupCfg.L2ChainID),
 	}
-	contract, err := inbox.NewInbox(predeploys.CrossL2InboxAddr, actors.ChainB.SequencerEngine.EthClient())
-	require.NoError(t, err)
-	tx, err := contract.ValidateMessage(auth, id, crypto.Keccak256Hash(fakeMessage))
-	require.NoError(t, err)
+	msgHash := crypto.Keccak256Hash(fakeMessage)
+	tx := newExecuteMessageTxFromIDAndHash(t, aliceB, actors.ChainB, id, msgHash)
 
 	actors.ChainB.Sequencer.ActL2StartBlock(t)
-	_, err = actors.ChainB.SequencerEngine.EngineApi.IncludeTx(tx, aliceB.address)
+	_, err := actors.ChainB.SequencerEngine.EngineApi.IncludeTx(tx, aliceB.address)
 	require.NoError(t, err)
 	actors.ChainB.Sequencer.ActL2EndBlock(t)
 	actors.ChainB.Sequencer.ActL2PipelineFull(t)
@@ -359,7 +353,6 @@ func TestInteropLocalSafeInvalidation(gt *testing.T) {
 }
 
 func TestInteropCrossSafeDependencyDelay(gt *testing.T) {
-	gt.Skip("temporarily broken by access-list change")
 	t := helpers.NewDefaultTesting(gt)
 
 	is := dsl.SetupInterop(t)
@@ -443,7 +436,6 @@ func TestInteropCrossSafeDependencyDelay(gt *testing.T) {
 }
 
 func TestInteropExecutingMessageOutOfRangeLogIndex(gt *testing.T) {
-	gt.Skip("temporarily broken by access-list change")
 	t := helpers.NewDefaultTesting(gt)
 	is := dsl.SetupInterop(t)
 	actors := is.CreateActors()
@@ -452,12 +444,12 @@ func TestInteropExecutingMessageOutOfRangeLogIndex(gt *testing.T) {
 
 	// Execute a fake log on chain A
 	chainBHead := actors.ChainB.Sequencer.SyncStatus().UnsafeL2
-	nonExistentID := inbox.Identifier{
+	nonExistentID := stypes.Identifier{
 		Origin:      aliceA.address,
-		BlockNumber: big.NewInt(int64(chainBHead.Number)),
-		LogIndex:    common.Big0,
-		Timestamp:   big.NewInt(int64(chainBHead.Time)),
-		ChainId:     actors.ChainB.RollupCfg.L2ChainID,
+		BlockNumber: chainBHead.Number,
+		LogIndex:    0,
+		Timestamp:   chainBHead.Time,
+		ChainID:     eth.ChainIDFromBig(actors.ChainB.RollupCfg.L2ChainID),
 	}
 	nonExistentHash := crypto.Keccak256Hash([]byte("fake message"))
 	tx := newExecuteMessageTxFromIDAndHash(t, aliceA, actors.ChainA, nonExistentID, nonExistentHash)

op-e2e/actions/interop/proofs_test.go

@@ -87,7 +87,6 @@ func TestInteropFaultProofs_TraceExtensionActivation(gt *testing.T) {
 }
 
 func TestInteropFaultProofs_ConsolidateValidCrossChainMessage(gt *testing.T) {
-	gt.Skip("temporarily broken by access-list change")
 	t := helpers.NewDefaultTesting(gt)
 	system := dsl.NewInteropDSL(t)
 	actors := system.Actors
@@ -367,7 +366,6 @@ func TestInteropFaultProofs(gt *testing.T) {
 }
 
 func TestInteropFaultProofs_IntraBlock(gt *testing.T) {
-	gt.Skip("temporarily broken by access-list change")
 	cases := []intraBlockTestCase{
 		new(cascadeInvalidBlockCase),
 		new(swapCascadeInvalidBlockCase),
@@ -447,7 +445,6 @@ func TestInteropFaultProofs_IntraBlock(gt *testing.T) {
 }
 
 func TestInteropFaultProofs_MessageExpiry(gt *testing.T) {
-	gt.Skip("temporarily broken by access-list change")
 	t := helpers.NewDefaultTesting(gt)
 	system := dsl.NewInteropDSL(t)
 
@@ -517,7 +514,6 @@ func TestInteropFaultProofs_MessageExpiry(gt *testing.T) {
 }
 
 func TestInteropFaultProofsInvalidBlock(gt *testing.T) {
-	gt.Skip("temporarily broken by access-list change")
 	t := helpers.NewDefaultTesting(gt)
 
 	system := dsl.NewInteropDSL(t)
@@ -1137,7 +1133,6 @@ func TestInteropFaultProofs_VariedBlockTimes_FasterChainB(gt *testing.T) {
 }
 
 func TestInteropFaultProofs_DepositMessage(gt *testing.T) {
-	gt.Skip("temporarily broken by access-list change")
 	t := helpers.NewDefaultTesting(gt)
 
 	system := dsl.NewInteropDSL(t)
@@ -1198,7 +1193,6 @@ func TestInteropFaultProofs_DepositMessage(gt *testing.T) {
 }
 
 func TestInteropFaultProofs_DepositMessage_InvalidExecution(gt *testing.T) {
-	gt.Skip("temporarily broken by access-list change")
 	t := helpers.NewDefaultTesting(gt)
 
 	system := dsl.NewInteropDSL(t)
@@ -1389,7 +1383,7 @@ func assertTime(t helpers.Testing, chain *dsl.Chain, unsafe, crossUnsafe, localS
 func assertUserDepositEmitted(t helpers.Testing, chain *dsl.Chain, number *big.Int, emitter *dsl.EmitterContract) {
 	block, err := chain.SequencerEngine.EthClient().BlockByNumber(t.Ctx(), number)
 	require.NoError(t, err)
-	require.GreaterOrEqual(t, len(block.Transactions()), 3) // l1-attrs + user-deposit + l1-attrs (end deposit contxt) + [txs]
+	require.GreaterOrEqual(t, len(block.Transactions()), 2) // l1-attrs + user-deposit + [txs]
 	userDepositTx := block.Transactions()[1]
 	require.NotNil(t, userDepositTx.To())
 	require.Equal(t, emitter.Address(chain), *userDepositTx.To())