draft: ban-deposits-interop first RFC draft

op-node/rollup/derive/attributes.go

@@ -121,9 +121,21 @@ func (ba *FetchingAttributesBuilder) PreparePayloadAttributes(ctx context.Contex
 		return nil, NewCriticalError(fmt.Errorf("failed to create l1InfoTx: %w", err))
 	}
 
-	txs := make([]hexutil.Bytes, 0, 1+len(depositTxs)+len(upgradeTxs))
+	var afterForceIncludeTxs []hexutil.Bytes
+	// TODO I'm usure if this needs to be only done AFTER interop is enabled, but not on the same block.
+	// This is similar to what Proto mentioned about blocking the ExecutingMessages on the same block as the interop activation.
+	if ba.rollupCfg.IsInterop(nextL2Time) {
+		depositsCompleteTx, err := DepositsCompleteBytes(seqNumber, l1Info)
+		if err != nil {
+			return nil, NewCriticalError(fmt.Errorf("failed to create depositsCompleteTx: %w", err))
+		}
+		afterForceIncludeTxs = append(afterForceIncludeTxs, depositsCompleteTx)
+	}
+
+	txs := make([]hexutil.Bytes, 0, 1+len(depositTxs)+len(afterForceIncludeTxs)+len(upgradeTxs))
 	txs = append(txs, l1InfoTx)
 	txs = append(txs, depositTxs...)
+	txs = append(txs, afterForceIncludeTxs...)
 	txs = append(txs, upgradeTxs...)
 
 	var withdrawals *types.Withdrawals

op-node/rollup/derive/attributes_test.go

@@ -195,6 +195,54 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		require.Equal(t, l1InfoTx, []byte(attrs.Transactions[0]))
 		require.True(t, attrs.NoTxPool)
 	})
+	t.Run("same origin with deposits on post-Isthmus", func(t *testing.T) {
+		rng := rand.New(rand.NewSource(1234))
+		l1Fetcher := &testutils.MockL1Source{}
+		defer l1Fetcher.AssertExpectations(t)
+		l2Parent := testutils.RandomL2BlockRef(rng)
+		l1CfgFetcher := &testutils.MockL2Client{}
+		l1CfgFetcher.ExpectSystemConfigByL2Hash(l2Parent.Hash, testSysCfg, nil)
+		defer l1CfgFetcher.AssertExpectations(t)
+		l1Info := testutils.RandomBlockInfo(rng)
+		l1Info.InfoParentHash = l2Parent.L1Origin.Hash
+		l1Info.InfoNum = l2Parent.L1Origin.Number + 1
+
+		receipts, depositTxs, err := makeReceipts(rng, l1Info.InfoHash, cfg.DepositContractAddress, []receiptData{
+			{goodReceipt: true, DepositLogs: []bool{true, false}},
+			{goodReceipt: true, DepositLogs: []bool{true}},
+			{goodReceipt: false, DepositLogs: []bool{true}},
+			{goodReceipt: false, DepositLogs: []bool{false}},
+		})
+		require.NoError(t, err)
+		usedDepositTxs, err := encodeDeposits(depositTxs)
+		require.NoError(t, err)
+
+		// sets config to post-interop
+		cfg.AfterHardfork(rollup.Interop, 2)
+
+		epoch := l1Info.ID()
+		l1InfoTx, err := L1InfoDepositBytes(cfg, testSysCfg, 0, l1Info, 0)
+		require.NoError(t, err)
+
+		l2Txs := append(append(make([]eth.Data, 0), l1InfoTx), usedDepositTxs...)
+
+		l1Fetcher.ExpectFetchReceipts(epoch.Hash, l1Info, receipts, nil)
+		attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, l1CfgFetcher)
+		attrs, err := attrBuilder.PreparePayloadAttributes(context.Background(), l2Parent, epoch)
+		require.NoError(t, err)
+		require.NotNil(t, attrs)
+		require.Equal(t, l2Parent.Time+cfg.BlockTime, uint64(attrs.Timestamp))
+		require.Equal(t, eth.Bytes32(l1Info.InfoMixDigest), attrs.PrevRandao)
+		require.Equal(t, predeploys.SequencerFeeVaultAddr, attrs.SuggestedFeeRecipient)
+		require.Equal(t, len(l2Txs), len(attrs.Transactions), "Expected txs to equal l1 info tx + user deposit txs + DepositsComplete")
+		require.Equal(t, l2Txs, attrs.Transactions)
+		require.Equal(t, DepositsCompleteBytes4, attrs.Transactions[1+len(depositTxs)][:4])
+		require.True(t, attrs.NoTxPool)
+		depositsCompleteTx, err := DepositsCompleteBytes(l2Parent.SequenceNumber, l1Info)
+		require.NoError(t, err)
+		require.Equal(t, l2Txs, append(attrs.Transactions, depositsCompleteTx))
+	})
+
 	// Test that the payload attributes builder changes the deposit format based on L2-time-based regolith activation
 	t.Run("regolith", func(t *testing.T) {
 		testCases := []struct {

op-node/rollup/derive/deposit_source.go

@@ -13,9 +13,10 @@ type UserDepositSource struct {
 }
 
 const (
-	UserDepositSourceDomain    = 0
-	L1InfoDepositSourceDomain  = 1
-	UpgradeDepositSourceDomain = 2
+	UserDepositSourceDomain       = 0
+	L1InfoDepositSourceDomain     = 1
+	UpgradeDepositSourceDomain    = 2
+	AfterForceIncludeSourceDomain = 3
 )
 
 func (dep *UserDepositSource) SourceHash() common.Hash {
@@ -63,3 +64,19 @@ func (dep *UpgradeDepositSource) SourceHash() common.Hash {
 	copy(domainInput[32:], intentHash[:])
 	return crypto.Keccak256Hash(domainInput[:])
 }
+
+// Used for DepositsComplete/ResetDeposits post-deposits transactions.
+type AfterForceIncludeSource struct {
+	L1BlockHash common.Hash
+}
+
+func (dep *AfterForceIncludeSource) SourceHash() common.Hash {
+	var input [32 * 2]byte
+	copy(input[:32], dep.L1BlockHash[:])
+	depositIDHash := crypto.Keccak256Hash(input[:])
+
+	var domainInput [32 * 2]byte
+	binary.BigEndian.PutUint64(domainInput[32-8:32], AfterForceIncludeSourceDomain)
+	copy(domainInput[32:], depositIDHash[:])
+	return crypto.Keccak256Hash(domainInput[:])
+}

op-node/rollup/derive/deposit_source_test.go

@@ -3,6 +3,7 @@ package derive
 import (
 	"testing"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -34,3 +35,17 @@ func TestEcotone4788ContractSourceHash(t *testing.T) {
 
 	assert.Equal(t, expected, actual.Hex())
 }
+
+// TestAfterForceIncludeSourceHash
+// cast keccak $(cast concat-hex 0x0000000000000000000000000000000000000000000000000000000000000003 $(cast keccak 0x01))
+// # 0x8afb1c4a581d0e71ab65334e3365ba5511fb15c13fa212776f9d4dafc6287845
+func TestAfterForceIncludeSource(t *testing.T) {
+	source := AfterForceIncludeSource{
+		L1BlockHash: common.Hash{0x01},
+	}
+
+	actual := source.SourceHash()
+	expected := "0x8afb1c4a581d0e71ab65334e3365ba5511fb15c13fa212776f9d4dafc6287845"
+
+	assert.Equal(t, expected, actual.Hex())
+}

op-node/rollup/derive/fuzz_parsers_test.go

@@ -83,15 +83,26 @@ func FuzzL1InfoEcotoneRoundTrip(f *testing.F) {
 		}
 		enc, err := in.marshalBinaryEcotone()
 		if err != nil {
-			t.Fatalf("Failed to marshal binary: %v", err)
+			t.Fatalf("Failed to marshal Ecotone binary: %v", err)
 		}
 		var out L1BlockInfo
 		err = out.unmarshalBinaryEcotone(enc)
 		if err != nil {
-			t.Fatalf("Failed to unmarshal binary: %v", err)
+			t.Fatalf("Failed to unmarshal Ecotone binary: %v", err)
 		}
 		if !cmp.Equal(in, out, cmp.Comparer(testutils.BigEqual)) {
-			t.Fatalf("The data did not round trip correctly. in: %v. out: %v", in, out)
+			t.Fatalf("The Ecotone data did not round trip correctly. in: %v. out: %v", in, out)
+		}
+		enc, err = in.marshalBinaryIsthmus()
+		if err != nil {
+			t.Fatalf("Failed to marshal Isthmus binary: %v", err)
+		}
+		err = out.unmarshalBinaryIsthmus(enc)
+		if err != nil {
+			t.Fatalf("Failed to unmarshal Isthmus binary: %v", err)
+		}
+		if !cmp.Equal(in, out, cmp.Comparer(testutils.BigEqual)) {
+			t.Fatalf("The Isthmus data did not round trip correctly. in: %v. out: %v", in, out)
 		}
 
 	})

op-node/rollup/derive/l1_block_info.go

@@ -20,14 +20,24 @@ import (
 const (
 	L1InfoFuncBedrockSignature = "setL1BlockValues(uint64,uint64,uint256,bytes32,uint64,bytes32,uint256,uint256)"
 	L1InfoFuncEcotoneSignature = "setL1BlockValuesEcotone()"
+	L1InfoFuncIsthmusSignature = "setL1BlockValuesIsthmus()"
+	DepositsCompleteSignature  = "depositsComplete()"
 	L1InfoArguments            = 8
 	L1InfoBedrockLen           = 4 + 32*L1InfoArguments
 	L1InfoEcotoneLen           = 4 + 32*5 // after Ecotone upgrade, args are packed into 5 32-byte slots
+	DepositsCompleteLen        = 4        // only the selector
+	// We set the gas limit to 15k to ensure that the DepositsComplete Transaction does not run out of gas.
+	// GasBenchMark_L1BlockIsthmus_DepositsComplete:test_depositsComplete_benchmark() (gas: 7768)
+	// GasBenchMark_L1BlockIsthmus_DepositsComplete_Warm:test_depositsComplete_benchmark() (gas: 5768)
+	// see `test_depositsComplete_benchmark` at: `/packages/contracts-bedrock/test/BenchmarkTest.t.sol`
+	DepositsCompleteGas = uint64(15_000)
 )
 
 var (
 	L1InfoFuncBedrockBytes4 = crypto.Keccak256([]byte(L1InfoFuncBedrockSignature))[:4]
 	L1InfoFuncEcotoneBytes4 = crypto.Keccak256([]byte(L1InfoFuncEcotoneSignature))[:4]
+	L1InfoFuncIsthmusBytes4 = crypto.Keccak256([]byte(L1InfoFuncIsthmusSignature))[:4]
+	DepositsCompleteBytes4  = crypto.Keccak256([]byte(DepositsCompleteSignature))[:4]
 	L1InfoDepositerAddress  = common.HexToAddress("0xdeaddeaddeaddeaddeaddeaddeaddeaddead0001")
 	L1BlockAddress          = predeploys.L1BlockAddr
 	ErrInvalidFormat        = errors.New("invalid ecotone l1 block info format")
@@ -144,7 +154,7 @@ func (info *L1BlockInfo) unmarshalBinaryBedrock(data []byte) error {
 	return nil
 }
 
-// Ecotone Binary Format
+// Isthmus & Ecotone Binary Format
 // +---------+--------------------------+
 // | Bytes   | Field                    |
 // +---------+--------------------------+
@@ -159,10 +169,24 @@ func (info *L1BlockInfo) unmarshalBinaryBedrock(data []byte) error {
 // | 32      | BlockHash                |
 // | 32      | BatcherHash              |
 // +---------+--------------------------+
-
+// Marshal Ecotone and Isthmus
 func (info *L1BlockInfo) marshalBinaryEcotone() ([]byte, error) {
-	w := bytes.NewBuffer(make([]byte, 0, L1InfoEcotoneLen))
-	if err := solabi.WriteSignature(w, L1InfoFuncEcotoneBytes4); err != nil {
+	out, err := marshalBinaryWithSignature(info, L1InfoFuncEcotoneBytes4)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal Ecotone l1 block info: %w", err)
+	}
+	return out, nil
+}
+func (info *L1BlockInfo) marshalBinaryIsthmus() ([]byte, error) {
+	out, err := marshalBinaryWithSignature(info, L1InfoFuncIsthmusBytes4)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal Isthmus l1 block info: %w", err)
+	}
+	return out, nil
+}
+func marshalBinaryWithSignature(info *L1BlockInfo, signature []byte) ([]byte, error) {
+	w := bytes.NewBuffer(make([]byte, 0, L1InfoEcotoneLen)) // Ecotone and Isthmus have the same length
+	if err := solabi.WriteSignature(w, signature); err != nil {
 		return nil, err
 	}
 	if err := binary.Write(w, binary.BigEndian, info.BaseFeeScalar); err != nil {
@@ -200,14 +224,21 @@ func (info *L1BlockInfo) marshalBinaryEcotone() ([]byte, error) {
 	return w.Bytes(), nil
 }
 
+// Unmarshal Ecotone and Isthmus
 func (info *L1BlockInfo) unmarshalBinaryEcotone(data []byte) error {
+	return unmarshalBinaryWithSignatureAndData(info, L1InfoFuncEcotoneBytes4, data)
+}
+func (info *L1BlockInfo) unmarshalBinaryIsthmus(data []byte) error {
+	return unmarshalBinaryWithSignatureAndData(info, L1InfoFuncIsthmusBytes4, data)
+}
+func unmarshalBinaryWithSignatureAndData(info *L1BlockInfo, signature []byte, data []byte) error {
 	if len(data) != L1InfoEcotoneLen {
 		return fmt.Errorf("data is unexpected length: %d", len(data))
 	}
 	r := bytes.NewReader(data)
 
 	var err error
-	if _, err := solabi.ReadAndValidateSignature(r, L1InfoFuncEcotoneBytes4); err != nil {
+	if _, err := solabi.ReadAndValidateSignature(r, signature); err != nil {
 		return err
 	}
 	if err := binary.Read(r, binary.BigEndian, &info.BaseFeeScalar); err != nil {
@@ -250,9 +281,24 @@ func isEcotoneButNotFirstBlock(rollupCfg *rollup.Config, l2BlockTime uint64) boo
 	return rollupCfg.IsEcotone(l2BlockTime) && !rollupCfg.IsEcotoneActivationBlock(l2BlockTime)
 }
 
+// isInteropButNotFirstBlock returns whether the specified block is subject to the Isthmus upgrade,
+// but is not the actiation block itself.
+func isInteropButNotFirstBlock(rollupCfg *rollup.Config, l2BlockTime uint64) bool {
+	// note from Proto:
+	// Since we use the pre-interop L1 tx one last time during the upgrade block,
+	// we must disallow the deposit-txs from using the CrossL2Inbox during this block.
+	// If the CrossL2Inbox does not exist yet, then it is safe,
+	// but we have to ensure that the spec and code puts any Interop upgrade-txs after the user deposits.
+	return rollupCfg.IsInterop(l2BlockTime) && !rollupCfg.IsInteropActivationBlock(l2BlockTime)
+}
+
 // L1BlockInfoFromBytes is the inverse of L1InfoDeposit, to see where the L2 chain is derived from
 func L1BlockInfoFromBytes(rollupCfg *rollup.Config, l2BlockTime uint64, data []byte) (*L1BlockInfo, error) {
 	var info L1BlockInfo
+	// Important, this should be ordered from most recent to oldest
+	if isInteropButNotFirstBlock(rollupCfg, l2BlockTime) {
+		return &info, info.unmarshalBinaryIsthmus(data)
+	}
 	if isEcotoneButNotFirstBlock(rollupCfg, l2BlockTime) {
 		return &info, info.unmarshalBinaryEcotone(data)
 	}
@@ -271,6 +317,7 @@ func L1InfoDeposit(rollupCfg *rollup.Config, sysCfg eth.SystemConfig, seqNumber
 		BatcherAddr:    sysCfg.BatcherAddr,
 	}
 	var data []byte
+
 	if isEcotoneButNotFirstBlock(rollupCfg, l2BlockTime) {
 		l1BlockInfo.BlobBaseFee = block.BlobBaseFee()
 		if l1BlockInfo.BlobBaseFee == nil {
@@ -283,11 +330,19 @@ func L1InfoDeposit(rollupCfg *rollup.Config, sysCfg eth.SystemConfig, seqNumber
 		}
 		l1BlockInfo.BlobBaseFeeScalar = scalars.BlobBaseFeeScalar
 		l1BlockInfo.BaseFeeScalar = scalars.BaseFeeScalar
-		out, err := l1BlockInfo.marshalBinaryEcotone()
-		if err != nil {
-			return nil, fmt.Errorf("failed to marshal Ecotone l1 block info: %w", err)
+		if isInteropButNotFirstBlock(rollupCfg, l2BlockTime) {
+			out, err := l1BlockInfo.marshalBinaryIsthmus()
+			if err != nil {
+				return nil, fmt.Errorf("failed to marshal Isthmus l1 block info: %w", err)
+			}
+			data = out
+		} else {
+			out, err := l1BlockInfo.marshalBinaryEcotone()
+			if err != nil {
+				return nil, fmt.Errorf("failed to marshal Ecotone l1 block info: %w", err)
+			}
+			data = out
 		}
-		data = out
 	} else {
 		l1BlockInfo.L1FeeOverhead = sysCfg.Overhead
 		l1BlockInfo.L1FeeScalar = sysCfg.Scalar
@@ -335,3 +390,33 @@ func L1InfoDepositBytes(rollupCfg *rollup.Config, sysCfg eth.SystemConfig, seqNu
 	}
 	return opaqueL1Tx, nil
 }
+
+func DepositsCompleteDeposit(seqNumber uint64, block eth.BlockInfo) (*types.DepositTx, error) {
+	source := AfterForceIncludeSource{
+		L1BlockHash: block.Hash(),
+	}
+	out := &types.DepositTx{
+		SourceHash:          source.SourceHash(),
+		From:                L1InfoDepositerAddress,
+		To:                  &L1BlockAddress,
+		Mint:                nil,
+		Value:               big.NewInt(0),
+		Gas:                 DepositsCompleteGas,
+		IsSystemTransaction: false,
+		Data:                DepositsCompleteBytes4,
+	}
+	return out, nil
+}
+
+func DepositsCompleteBytes(seqNumber uint64, l1Info eth.BlockInfo) ([]byte, error) {
+	dep, err := DepositsCompleteDeposit(seqNumber, l1Info)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create DepositsComplete tx: %w", err)
+	}
+	depositsCompleteTx := types.NewTx(dep)
+	opaqueDepositsCompleteTx, err := depositsCompleteTx.MarshalBinary()
+	if err != nil {
+		return nil, fmt.Errorf("failed to encode DepositsComplete tx: %w", err)
+	}
+	return opaqueDepositsCompleteTx, nil
+}