Merge branch 'develop' into aj/e2e-helpers

.changeset/new-mails-explain.md

+---
+'@eth-optimism/contracts-bedrock': minor
+---
+
+Bump XDM semver after #5444

.changeset/old-poets-camp.md

+---
+'@eth-optimism/chain-mon': patch
+---
+
+Fixes a bug in the wd-mon service where a node connection failure event was not handled correctly

.circleci/config.yml

@@ -535,6 +535,55 @@ jobs:
           name: Upload coverage
           command: codecov --verbose --clean --flags <<parameters.coverage_flag>>
 
+  sdk-next-tests:
+    docker:
+      - image: ethereumoptimism/ci-builder:latest
+    resource_class: large
+    steps:
+      - checkout
+      - attach_workspace: { at: "." }
+      - check-changed:
+          patterns: sdk,contracts-bedrock,contracts
+      - restore_cache:
+          name: Restore Yarn Package Cache
+          keys:
+            - yarn-packages-v2-{{ checksum "yarn.lock" }}
+      - run:
+          name: anvil-l1
+          background: true
+          # atm this is goerli but we should use mainnet after bedrock is live
+          command: anvil --fork-url $ANVIL_L1_FORK_URL --fork-block-number 8847426
+      - run:
+          name: anvil-l2
+          background: true
+          # atm this is goerli but we should use mainnet after bedrock is live
+          command: anvil --fork-url $ANVIL_L2_FORK_URL --port 9545 --fork-block-number 8172732
+      - run:
+          name: build
+          command: yarn build
+          working_directory: packages/atst
+      - run:
+          name: lint
+          command: yarn lint:check
+          working_directory: packages/atst
+      - run:
+          name: make sure anvil l1 is up
+          command: npx wait-on tcp:8545 && cast block-number --rpc-url http://localhost:8545
+      - run:
+          name: make sure anvil l2 is up
+          command: npx wait-on tcp:9545 && cast block-number --rpc-url http://localhost:9545
+      - run:
+          name: test:next
+          command: yarn test:next
+          no_output_timeout: 5m
+          working_directory: packages/sdk
+          environment:
+            # anvil[0] test private key
+            VITE_E2E_PRIVATE_KEY: "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+            VITE_E2E_RPC_URL_L1: http://localhost:8545
+            VITE_E2E_RPC_URL_L2: http://localhost:9545
+
+
   bedrock-markdown:
     machine:
       image: ubuntu-2204:2022.07.1
@@ -1094,6 +1143,10 @@ workflows:
           dependencies: "(common-ts|core-utils)"
           requires:
             - yarn-monorepo
+      - sdk-next-tests:
+          name: sdk-next-tests
+          requires:
+            - yarn-monorepo
       - js-lint-test:
           name: sdk-tests
           coverage_flag: sdk-tests

op-node/rollup/derive/l1_block_info.go

@@ -2,9 +2,8 @@ package derive
 
 import (
 	"bytes"
-	"encoding/binary"
+	"errors"
 	"fmt"
-	"io"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -13,6 +12,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-service/solabi"
 )
 
 const (
@@ -46,52 +46,51 @@ type L1BlockInfo struct {
 	L1FeeScalar   eth.Bytes32
 }
 
-//+---------+--------------------------+
-//| Bytes   | Field                    |
-//+---------+--------------------------+
-//| 4       | Function signature       |
-//| 24      | Padding for Number       |
-//| 8       | Number                   |
-//| 24      | Padding for Time         |
-//| 8       | Time                     |
-//| 32      | BaseFee                  |
-//| 32      | BlockHash                |
-//| 24      | Padding for SequenceNumber|
-//| 8       | SequenceNumber           |
-//| 12      | Padding for BatcherAddr  |
-//| 20      | BatcherAddr              |
-//| 32      | L1FeeOverhead            |
-//| 32      | L1FeeScalar              |
-//+---------+--------------------------+
+// Binary Format
+// +---------+--------------------------+
+// | Bytes   | Field                    |
+// +---------+--------------------------+
+// | 4       | Function signature       |
+// | 32      | Number                   |
+// | 32      | Time                     |
+// | 32      | BaseFee                  |
+// | 32      | BlockHash                |
+// | 32      | SequenceNumber           |
+// | 32      | BatcherAddr              |
+// | 32      | L1FeeOverhead            |
+// | 32      | L1FeeScalar              |
+// +---------+--------------------------+
 
 func (info *L1BlockInfo) MarshalBinary() ([]byte, error) {
-	writer := bytes.NewBuffer(make([]byte, 0, L1InfoLen))
-
-	writer.Write(L1InfoFuncBytes4)
-	if err := writeSolidityABIUint64(writer, info.Number); err != nil {
+	w := bytes.NewBuffer(make([]byte, 0, L1InfoLen))
+	if err := solabi.WriteSignature(w, L1InfoFuncBytes4); err != nil {
 		return nil, err
 	}
-	if err := writeSolidityABIUint64(writer, info.Time); err != nil {
+	if err := solabi.WriteUint64(w, info.Number); err != nil {
 		return nil, err
 	}
-	// Ensure that the baseFee is not too large.
-	if info.BaseFee.BitLen() > 256 {
-		return nil, fmt.Errorf("base fee exceeds 256 bits: %d", info.BaseFee)
+	if err := solabi.WriteUint64(w, info.Time); err != nil {
+		return nil, err
 	}
-	var baseFeeBuf [32]byte
-	info.BaseFee.FillBytes(baseFeeBuf[:])
-	writer.Write(baseFeeBuf[:])
-	writer.Write(info.BlockHash.Bytes())
-	if err := writeSolidityABIUint64(writer, info.SequenceNumber); err != nil {
+	if err := solabi.WriteUint256(w, info.BaseFee); err != nil {
 		return nil, err
 	}
-
-	var addrPadding [12]byte
-	writer.Write(addrPadding[:])
-	writer.Write(info.BatcherAddr.Bytes())
-	writer.Write(info.L1FeeOverhead[:])
-	writer.Write(info.L1FeeScalar[:])
-	return writer.Bytes(), nil
+	if err := solabi.WriteHash(w, info.BlockHash); err != nil {
+		return nil, err
+	}
+	if err := solabi.WriteUint64(w, info.SequenceNumber); err != nil {
+		return nil, err
+	}
+	if err := solabi.WriteAddress(w, info.BatcherAddr); err != nil {
+		return nil, err
+	}
+	if err := solabi.WriteEthBytes32(w, info.L1FeeOverhead); err != nil {
+		return nil, err
+	}
+	if err := solabi.WriteEthBytes32(w, info.L1FeeScalar); err != nil {
+		return nil, err
+	}
+	return w.Bytes(), nil
 }
 
 func (info *L1BlockInfo) UnmarshalBinary(data []byte) error {
@@ -100,81 +99,40 @@ func (info *L1BlockInfo) UnmarshalBinary(data []byte) error {
 	}
 	reader := bytes.NewReader(data)
 
-	funcSignature := make([]byte, 4)
-	if _, err := io.ReadFull(reader, funcSignature); err != nil || !bytes.Equal(funcSignature, L1InfoFuncBytes4) {
-		return fmt.Errorf("data does not match L1 info function signature: 0x%x", funcSignature)
-	}
-
-	if blockNumber, err := readSolidityABIUint64(reader); err != nil {
+	var err error
+	if _, err := solabi.ReadAndValidateSignature(reader, L1InfoFuncBytes4); err != nil {
 		return err
-	} else {
-		info.Number = blockNumber
 	}
-	if blockTime, err := readSolidityABIUint64(reader); err != nil {
+	if info.Number, err = solabi.ReadUint64(reader); err != nil {
 		return err
-	} else {
-		info.Time = blockTime
 	}
-
-	var baseFeeBytes [32]byte
-	if _, err := io.ReadFull(reader, baseFeeBytes[:]); err != nil {
-		return fmt.Errorf("expected BaseFee length to be 32 bytes, but got %x", baseFeeBytes)
-	}
-	info.BaseFee = new(big.Int).SetBytes(baseFeeBytes[:])
-	var blockHashBytes [32]byte
-	if _, err := io.ReadFull(reader, blockHashBytes[:]); err != nil {
-		return fmt.Errorf("expected BlockHash length to be 32 bytes, but got %x", blockHashBytes)
-	}
-	info.BlockHash.SetBytes(blockHashBytes[:])
-
-	if sequenceNumber, err := readSolidityABIUint64(reader); err != nil {
+	if info.Time, err = solabi.ReadUint64(reader); err != nil {
 		return err
-	} else {
-		info.SequenceNumber = sequenceNumber
 	}
-
-	var addrPadding [12]byte
-	if _, err := io.ReadFull(reader, addrPadding[:]); err != nil {
-		return fmt.Errorf("expected addrPadding length to be 12 bytes, but got %x", addrPadding)
+	if info.BaseFee, err = solabi.ReadUint256(reader); err != nil {
+		return err
 	}
-	if _, err := io.ReadFull(reader, info.BatcherAddr[:]); err != nil {
-		return fmt.Errorf("expected BatcherAddr length to be 20 bytes, but got %x", info.BatcherAddr)
+	if info.BlockHash, err = solabi.ReadHash(reader); err != nil {
+		return err
 	}
-	if _, err := io.ReadFull(reader, info.L1FeeOverhead[:]); err != nil {
-		return fmt.Errorf("expected L1FeeOverhead length to be 32 bytes, but got %x", info.L1FeeOverhead)
+	if info.SequenceNumber, err = solabi.ReadUint64(reader); err != nil {
+		return err
 	}
-	if _, err := io.ReadFull(reader, info.L1FeeScalar[:]); err != nil {
-		return fmt.Errorf("expected L1FeeScalar length to be 32 bytes, but got %x", info.L1FeeScalar)
+	if info.BatcherAddr, err = solabi.ReadAddress(reader); err != nil {
+		return err
 	}
-
-	return nil
-}
-
-func writeSolidityABIUint64(w io.Writer, num uint64) error {
-	var padding [24]byte
-	if _, err := w.Write(padding[:]); err != nil {
+	if info.L1FeeOverhead, err = solabi.ReadEthBytes32(reader); err != nil {
 		return err
 	}
-	if err := binary.Write(w, binary.BigEndian, num); err != nil {
+	if info.L1FeeScalar, err = solabi.ReadEthBytes32(reader); err != nil {
 		return err
 	}
+	if !solabi.EmptyReader(reader) {
+		return errors.New("too many bytes")
+	}
 	return nil
 }
 
-func readSolidityABIUint64(r io.Reader) (uint64, error) {
-	var (
-		padding, readPadding [24]byte
-		num                  uint64
-	)
-	if _, err := io.ReadFull(r, readPadding[:]); err != nil || !bytes.Equal(readPadding[:], padding[:]) {
-		return 0, fmt.Errorf("L1BlockInfo number exceeds uint64 bounds: %x", readPadding[:])
-	}
-	if err := binary.Read(r, binary.BigEndian, &num); err != nil {
-		return 0, fmt.Errorf("L1BlockInfo expected number length to be 8 bytes")
-	}
-	return num, nil
-}
-
 // L1InfoDepositTxData is the inverse of L1InfoDeposit, to see where the L2 chain is derived from
 func L1InfoDepositTxData(data []byte) (L1BlockInfo, error) {
 	var info L1BlockInfo

op-node/rollup/derive/system_config.go

@@ -2,7 +2,7 @@ package derive
 
 import (
 	"bytes"
-	"encoding/binary"
+	"errors"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -12,6 +12,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-service/solabi"
 )
 
 var (
@@ -27,17 +28,6 @@ var (
 	ConfigUpdateEventVersion0 = common.Hash{}
 )
 
-var (
-	// A left-padded uint256 equal to 32.
-	oneWordUint = common.Hash{31: 32}
-	// A left-padded uint256 equal to 64.
-	twoWordUint = common.Hash{31: 64}
-	// 24 zero bytes (the padding for a uint64 in a 32 byte word)
-	uint64Padding = make([]byte, 24)
-	// 12 zero bytes (the padding for an Ethereum address in a 32 byte word)
-	addressPadding = make([]byte, 12)
-)
-
 // UpdateSystemConfigWithL1Receipts filters all L1 receipts to find config updates and applies the config updates to the given sysCfg
 func UpdateSystemConfigWithL1Receipts(sysCfg *eth.SystemConfig, receipts []*types.Receipt, cfg *rollup.Config) error {
 	var result error
@@ -84,90 +74,60 @@ func ProcessSystemConfigUpdateLogEvent(destSysCfg *eth.SystemConfig, ev *types.L
 	// Create a reader of the unindexed data
 	reader := bytes.NewReader(ev.Data)
 
-	// Counter for the number of bytes read from `reader` via `readWord`
-	countReadBytes := 0
-
-	// Helper function to read a word from the log data reader
-	readWord := func() (b [32]byte) {
-		if _, err := reader.Read(b[:]); err != nil {
-			// If there is an error reading the next 32 bytes from the reader, return an empty
-			// 32 byte array. We always check that the number of bytes read (`countReadBytes`)
-			// is equal to the expected amount at the end of each switch case.
-			return b
-		}
-		countReadBytes += 32
-		return b
-	}
-
 	// Attempt to read unindexed data
 	switch updateType {
 	case SystemConfigUpdateBatcher:
-		// Read the pointer, it should always equal 32.
-		if word := readWord(); word != oneWordUint {
-			return fmt.Errorf("expected offset to point to length location, but got %s", word)
+		if pointer, err := solabi.ReadUint64(reader); err != nil || pointer != 32 {
+			return NewCriticalError(errors.New("invalid pointer field"))
 		}
-
-		// Read the length, it should also always equal 32.
-		if word := readWord(); word != oneWordUint {
-			return fmt.Errorf("expected length to be 32 bytes, but got %s", word)
+		if length, err := solabi.ReadUint64(reader); err != nil || length != 32 {
+			return NewCriticalError(errors.New("invalid length field"))
 		}
-
-		// Indexing `word` directly is always safe here, it is guaranteed to be 32 bytes in length.
-		// Check that the batcher address is correctly zero-padded.
-		word := readWord()
-		if !bytes.Equal(word[:12], addressPadding) {
-			return fmt.Errorf("expected version 0 batcher hash with zero padding, but got %x", word)
+		address, err := solabi.ReadAddress(reader)
+		if err != nil {
+			return NewCriticalError(errors.New("could not read address"))
 		}
-		destSysCfg.BatcherAddr.SetBytes(word[12:])
-
-		if countReadBytes != 32*3 {
-			return NewCriticalError(fmt.Errorf("expected 32*3 bytes in batcher hash update, but got %d bytes", len(ev.Data)))
+		if !solabi.EmptyReader(reader) {
+			return NewCriticalError(errors.New("too many bytes"))
 		}
-
+		destSysCfg.BatcherAddr = address
 		return nil
 	case SystemConfigUpdateGasConfig:
-		// Read the pointer, it should always equal 32.
-		if word := readWord(); word != oneWordUint {
-			return fmt.Errorf("expected offset to point to length location, but got %s", word)
+		if pointer, err := solabi.ReadUint64(reader); err != nil || pointer != 32 {
+			return NewCriticalError(errors.New("invalid pointer field"))
 		}
-
-		// Read the length, it should always equal 64.
-		if word := readWord(); word != twoWordUint {
-			return fmt.Errorf("expected length to be 64 bytes, but got %s", word)
+		if length, err := solabi.ReadUint64(reader); err != nil || length != 64 {
+			return NewCriticalError(errors.New("invalid length field"))
 		}
-
-		// Set the system config's overhead and scalar values to the values read from the log
-		destSysCfg.Overhead = readWord()
-		destSysCfg.Scalar = readWord()
-
-		if countReadBytes != 32*4 {
-			return NewCriticalError(fmt.Errorf("expected 32*4 bytes in GPO params update data, but got %d", len(ev.Data)))
+		overhead, err := solabi.ReadEthBytes32(reader)
+		if err != nil {
+			return NewCriticalError(errors.New("could not read overhead"))
 		}
-
+		scalar, err := solabi.ReadEthBytes32(reader)
+		if err != nil {
+			return NewCriticalError(errors.New("could not read scalar"))
+		}
+		if !solabi.EmptyReader(reader) {
+			return NewCriticalError(errors.New("too many bytes"))
+		}
+		destSysCfg.Overhead = overhead
+		destSysCfg.Scalar = scalar
 		return nil
 	case SystemConfigUpdateGasLimit:
-		// Read the pointer, it should always equal 32.
-		if word := readWord(); word != oneWordUint {
-			return fmt.Errorf("expected offset to point to length location, but got %s", word)
+		if pointer, err := solabi.ReadUint64(reader); err != nil || pointer != 32 {
+			return NewCriticalError(errors.New("invalid pointer field"))
 		}
-
-		// Read the length, it should also always equal 32.
-		if word := readWord(); word != oneWordUint {
-			return fmt.Errorf("expected length to be 32 bytes, but got %s", word)
+		if length, err := solabi.ReadUint64(reader); err != nil || length != 32 {
+			return NewCriticalError(errors.New("invalid length field"))
 		}
-
-		// Indexing `word` directly is always safe here, it is guaranteed to be 32 bytes in length.
-		// Check that the gas limit is correctly zero-padded.
-		word := readWord()
-		if !bytes.Equal(word[:24], uint64Padding) {
-			return fmt.Errorf("expected zero padding for gaslimit, but got %x", word)
+		gasLimit, err := solabi.ReadUint64(reader)
+		if err != nil {
+			return NewCriticalError(errors.New("could not read gas limit"))
 		}
-		destSysCfg.GasLimit = binary.BigEndian.Uint64(word[24:])
-
-		if countReadBytes != 32*3 {
-			return NewCriticalError(fmt.Errorf("expected 32*3 bytes in gas limit update, but got %d bytes", len(ev.Data)))
+		if !solabi.EmptyReader(reader) {
+			return NewCriticalError(errors.New("too many bytes"))
 		}
-
+		destSysCfg.GasLimit = gasLimit
 		return nil
 	case SystemConfigUpdateUnsafeBlockSigner:
 		// Ignored in derivation. This configurable applies to runtime configuration outside of the derivation.

op-service/solabi/util.go

+package solabi
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// These are empty padding values. They should be zero'd & not modified at all.
+var (
+	addressEmptyPadding [12]byte = [12]byte{}
+	uint64EmptyPadding  [24]byte = [24]byte{}
+)
+
+func ReadSignature(r io.Reader) ([]byte, error) {
+	sig := make([]byte, 4)
+	_, err := io.ReadFull(r, sig)
+	return sig, err
+}
+
+func ReadAndValidateSignature(r io.Reader, expectedSignature []byte) ([]byte, error) {
+	sig := make([]byte, 4)
+	if _, err := io.ReadFull(r, sig); err != nil {
+		return nil, err
+	}
+	if !bytes.Equal(sig, expectedSignature) {
+		return nil, errors.New("invalid function signature")
+	}
+	return sig, nil
+}
+
+func ReadHash(r io.Reader) (common.Hash, error) {
+	var h common.Hash
+	_, err := io.ReadFull(r, h[:])
+	return h, err
+}
+
+func ReadEthBytes32(r io.Reader) (eth.Bytes32, error) {
+	var b eth.Bytes32
+	_, err := io.ReadFull(r, b[:])
+	return b, err
+}
+
+func ReadAddress(r io.Reader) (common.Address, error) {
+	var readPadding [12]byte
+	var a common.Address
+	if _, err := io.ReadFull(r, readPadding[:]); err != nil {
+		return a, err
+	} else if !bytes.Equal(readPadding[:], addressEmptyPadding[:]) {
+		return a, fmt.Errorf("address padding was not empty: %x", readPadding[:])
+	}
+	_, err := io.ReadFull(r, a[:])
+	return a, err
+}
+
+// ReadUint64 reads a big endian uint64 from a 32 byte word
+func ReadUint64(r io.Reader) (uint64, error) {
+	var readPadding [24]byte
+	var n uint64
+	if _, err := io.ReadFull(r, readPadding[:]); err != nil {
+		return n, err
+	} else if !bytes.Equal(readPadding[:], uint64EmptyPadding[:]) {
+		return n, fmt.Errorf("number padding was not empty: %x", readPadding[:])
+	}
+	if err := binary.Read(r, binary.BigEndian, &n); err != nil {
+		return 0, fmt.Errorf("expected number length to be 8 bytes")
+	}
+	return n, nil
+}
+
+func ReadUint256(r io.Reader) (*big.Int, error) {
+	var n [32]byte
+	if _, err := io.ReadFull(r, n[:]); err != nil {
+		return nil, err
+	}
+	return new(big.Int).SetBytes(n[:]), nil
+}
+
+func EmptyReader(r io.Reader) bool {
+	var t [1]byte
+	n, err := r.Read(t[:])
+	return n == 0 && err == io.EOF
+}
+
+func WriteSignature(w io.Writer, sig []byte) error {
+	_, err := w.Write(sig)
+	return err
+}
+
+func WriteHash(w io.Writer, h common.Hash) error {
+	_, err := w.Write(h[:])
+	return err
+}
+
+func WriteEthBytes32(w io.Writer, b eth.Bytes32) error {
+	_, err := w.Write(b[:])
+	return err
+}
+
+func WriteAddress(w io.Writer, a common.Address) error {
+	if _, err := w.Write(addressEmptyPadding[:]); err != nil {
+		return err
+	}
+	if _, err := w.Write(a[:]); err != nil {
+		return err
+	}
+	return nil
+}
+
+func WriteUint256(w io.Writer, n *big.Int) error {
+	if n.BitLen() > 256 {
+		return fmt.Errorf("big int exceeds 256 bits: %d", n)
+	}
+	arr := make([]byte, 32)
+	n.FillBytes(arr)
+	_, err := w.Write(arr)
+	return err
+}
+
+func WriteUint64(w io.Writer, n uint64) error {
+	if _, err := w.Write(uint64EmptyPadding[:]); err != nil {
+		return err
+	}
+	if err := binary.Write(w, binary.BigEndian, n); err != nil {
+		return err
+	}
+	return nil
+}

op-service/solabi/utils_test.go

+package solabi_test
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-service/solabi"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEmptyReader(t *testing.T) {
+	t.Run("empty", func(t *testing.T) {
+		r := new(bytes.Buffer)
+		require.True(t, solabi.EmptyReader(r))
+	})
+	t.Run("empty after read", func(t *testing.T) {
+		r := bytes.NewBufferString("not empty")
+		tmp := make([]byte, 9)
+		n, err := r.Read(tmp)
+		require.Equal(t, 9, n)
+		require.NoError(t, err)
+		require.True(t, solabi.EmptyReader(r))
+	})
+	t.Run("extra bytes", func(t *testing.T) {
+		r := bytes.NewBufferString("not empty")
+		require.False(t, solabi.EmptyReader(r))
+	})
+}

packages/chain-mon/src/wd-mon/service.ts

@@ -142,7 +142,7 @@ export class WithdrawalMonitor extends BaseServiceV2<Options, Metrics, State> {
         section: 'getBlockNumber',
       })
       this.metrics.nodeConnectionFailures.inc({
-        chainId: this.state.messenger.l1ChainId,
+        layer: 'l1',
         section: 'getBlockNumber',
       })
       await sleep(this.options.sleepTimeMs)

packages/contracts-bedrock/contracts/L1/L1CrossDomainMessenger.sol

@@ -20,12 +20,12 @@ contract L1CrossDomainMessenger is CrossDomainMessenger, Semver {
     OptimismPortal public immutable PORTAL;
 
     /**
-     * @custom:semver 1.1.0
+     * @custom:semver 1.2.0
      *
      * @param _portal Address of the OptimismPortal contract on this network.
      */
     constructor(OptimismPortal _portal)
-        Semver(1, 1, 0)
+        Semver(1, 2, 0)
         CrossDomainMessenger(Predeploys.L2_CROSS_DOMAIN_MESSENGER)
     {
         PORTAL = _portal;

packages/contracts-bedrock/contracts/L2/L2CrossDomainMessenger.sol

@@ -17,12 +17,12 @@ import { L2ToL1MessagePasser } from "./L2ToL1MessagePasser.sol";
  */
 contract L2CrossDomainMessenger is CrossDomainMessenger, Semver {
     /**
-     * @custom:semver 1.1.0
+     * @custom:semver 1.2.0
      *
      * @param _l1CrossDomainMessenger Address of the L1CrossDomainMessenger contract.
      */
     constructor(address _l1CrossDomainMessenger)
-        Semver(1, 1, 0)
+        Semver(1, 2, 0)
         CrossDomainMessenger(_l1CrossDomainMessenger)
     {
         initialize();

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

@@ -92,7 +92,7 @@ contract ExternalRelay is CommonTest {
     /**
      * @notice Helper function to get the callData for an `externalCallWithMinGas
      */
-    function getCallData() public returns (bytes memory) {
+    function getCallData() public pure returns (bytes memory) {
         return abi.encodeWithSelector(ExternalRelay.externalCallWithMinGas.selector);
     }
 

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

@@ -23,6 +23,8 @@ contract SafeCall_call_Test is CommonTest {
         vm.assume(to != address(0x000000000000000000636F6e736F6c652e6c6f67));
         // don't call the create2 deployer
         vm.assume(to != address(0x4e59b44847b379578588920cA78FbF26c0B4956C));
+        // don't call the ffi interface
+        vm.assume(to != address(0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f));
 
         assertEq(from.balance, 0, "from balance is 0");
         vm.deal(from, value);

packages/contracts-bedrock/tasks/check-l2.ts

@@ -245,7 +245,7 @@ const check = {
     await assertSemver(
       L2CrossDomainMessenger,
       'L2CrossDomainMessenger',
-      '1.1.0'
+      '1.2.0'
     )
 
     const xDomainMessageSenderSlot = await signer.provider.getStorageAt(

packages/sdk/package.json

@@ -17,6 +17,7 @@
     "lint:fix": "yarn lint:check --fix",
     "pre-commit": "lint-staged",
     "test": "hardhat test",
+    "test:next": "vitest test-next/proveMessage.spec.ts",
     "test:coverage": "nyc hardhat test && nyc merge .nyc_output coverage.json",
     "autogen:docs": "typedoc --out docs src/index.ts"
   },
@@ -45,7 +46,9 @@
     "hardhat-deploy": "^0.11.4",
     "nyc": "^15.1.0",
     "typedoc": "^0.22.13",
-    "mocha": "^10.0.0"
+    "mocha": "^10.0.0",
+    "vitest": "^0.28.3",
+    "zod": "^3.11.6"
   },
   "dependencies": {
     "@eth-optimism/contracts": "0.5.40",

packages/sdk/src/cross-chain-messenger.ts

@@ -68,6 +68,7 @@ import {
   migratedWithdrawalGasLimit,
   DEPOSIT_CONFIRMATION_BLOCKS,
   CHAIN_BLOCK_TIMES,
+  hashMessageHash,
 } from './utils'
 
 export class CrossChainMessenger {
@@ -351,14 +352,12 @@ export class CrossChainMessenger {
       }
     }
 
-    const minGasLimit = migratedWithdrawalGasLimit(resolved.message)
-
     return {
       ...resolved,
       value,
-      minGasLimit,
+      minGasLimit: BigNumber.from(0),
       messageNonce: encodeVersionedNonce(
-        BigNumber.from(1),
+        BigNumber.from(0),
         resolved.messageNonce
       ),
     }
@@ -388,13 +387,23 @@ export class CrossChainMessenger {
       updated = resolved
     }
 
+    // Encode the updated message, we need this for legacy messages.
+    const encoded = encodeCrossDomainMessageV1(
+      updated.messageNonce,
+      updated.sender,
+      updated.target,
+      updated.value,
+      updated.minGasLimit,
+      updated.message
+    )
+
     // We need to figure out the final withdrawal data that was used to compute the withdrawal hash
     // inside the L2ToL1Message passer contract. Exact mechanism here depends on whether or not
     // this is a legacy message or a new Bedrock message.
     let gasLimit: BigNumber
     let messageNonce: BigNumber
     if (version.eq(0)) {
-      gasLimit = BigNumber.from(0)
+      gasLimit = migratedWithdrawalGasLimit(encoded)
       messageNonce = resolved.messageNonce
     } else {
       const receipt = await this.l2Provider.getTransactionReceipt(
@@ -433,14 +442,7 @@ export class CrossChainMessenger {
       target: this.contracts.l1.L1CrossDomainMessenger.address,
       value: updated.value,
       minGasLimit: gasLimit,
-      message: encodeCrossDomainMessageV1(
-        updated.messageNonce,
-        updated.sender,
-        updated.target,
-        updated.value,
-        updated.minGasLimit,
-        updated.message
-      ),
+      message: encoded,
     }
   }
 
@@ -572,6 +574,9 @@ export class CrossChainMessenger {
   public async toCrossChainMessage(
     message: MessageLike
   ): Promise<CrossChainMessage> {
+    if (!message) {
+      throw new Error('message is undefined')
+    }
     // TODO: Convert these checks into proper type checks.
     if ((message as CrossChainMessage).message) {
       return message as CrossChainMessage
@@ -1357,12 +1362,8 @@ export class CrossChainMessenger {
     }
 
     const withdrawal = await this.toLowLevelMessage(resolved)
-    const messageSlot = ethers.utils.keccak256(
-      ethers.utils.defaultAbiCoder.encode(
-        ['bytes32', 'uint256'],
-        [hashLowLevelMessage(withdrawal), ethers.constants.HashZero]
-      )
-    )
+    const hash = hashLowLevelMessage(withdrawal)
+    const messageSlot = hashMessageHash(hash)
 
     const stateTrieProof = await makeStateTrieProof(
       this.l2Provider as ethers.providers.JsonRpcProvider,
@@ -1462,9 +1463,8 @@ export class CrossChainMessenger {
       overrides?: Overrides
     }
   ): Promise<TransactionResponse> {
-    return (opts?.signer || this.l1Signer).sendTransaction(
-      await this.populateTransaction.proveMessage(message, opts)
-    )
+    const tx = await this.populateTransaction.proveMessage(message, opts)
+    return (opts?.signer || this.l1Signer).sendTransaction(tx)
   }
 
   /**
@@ -1768,7 +1768,8 @@ export class CrossChainMessenger {
 
       const withdrawal = await this.toLowLevelMessage(resolved)
       const proof = await this.getBedrockMessageProof(resolved)
-      return this.contracts.l1.OptimismPortal.populateTransaction.proveWithdrawalTransaction(
+
+      const args = [
         [
           withdrawal.messageNonce,
           withdrawal.sender,
@@ -1785,7 +1786,11 @@ export class CrossChainMessenger {
           proof.outputRootProof.latestBlockhash,
         ],
         proof.withdrawalProof,
-        opts?.overrides || {}
+        opts?.overrides || {},
+      ] as const
+
+      return this.contracts.l1.OptimismPortal.populateTransaction.proveWithdrawalTransaction(
+        ...args
       )
     },
 

packages/sdk/src/utils/message-utils.ts

 import { hashWithdrawal } from '@eth-optimism/core-utils'
-import { BigNumber, utils } from 'ethers'
+import { BigNumber, utils, ethers } from 'ethers'
 
 import { LowLevelMessage } from '../interfaces'
 
@@ -22,6 +22,22 @@ export const hashLowLevelMessage = (message: LowLevelMessage): string => {
   )
 }
 
+/**
+ * Utility for hashing a message hash. This computes the storage slot
+ * where the message hash will be stored in state. HashZero is used
+ * because the first mapping in the contract is used.
+ *
+ * @param messageHash Message hash to hash.
+ * @returns Hash of the given message hash.
+ */
+export const hashMessageHash = (messageHash: string): string => {
+  const data = ethers.utils.defaultAbiCoder.encode(
+    ['bytes32', 'uint256'],
+    [messageHash, ethers.constants.HashZero]
+  )
+  return ethers.utils.keccak256(data)
+}
+
 /**
  * Compute the min gas limit for a migrated withdrawal.
  */

packages/sdk/test-next/README.md

+# test-next
+
+- The new tests for the next version of sdk will use vitest
+- The vitest tests are kept here seperated from mocha tests for now

packages/sdk/test-next/proveMessage.spec.ts

+import ethers from 'ethers'
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod'
+
+import { CrossChainMessenger } from '../src'
+
+/**
+ * This test repros the bug where legacy withdrawals are not provable
+ */
+/*******
+Cast results from runnning cast tx and cast receipt on the l2 tx hash
+
+cast tx 0xd66fda632b51a8b25a9d260d70da8be57b9930c4616370861526335c3e8eef81 --rpc-url https://goerli.optimism.io
+
+blockHash            0x67956cee3de38d49206d34b77f560c4c371d77b36584047ade8bf7b67bf210c0
+blockNumber          2337599
+from                 0x1d86C2F5cc7fBEc35FEDbd3293b5004A841EA3F0
+gas                  118190
+gasPrice             1
+hash                 0xd66fda632b51a8b25a9d260d70da8be57b9930c4616370861526335c3e8eef81
+input                0x32b7006d000000000000000000000000deaddeaddeaddeaddeaddeaddeaddeaddead000000000000000000000000000000000000000000000000000000005af3107a4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000
+nonce                10
+r                    0x7e58c5dbb37f57303d936562d89a75a20be2a45f54c5d44dc73119453adf2e08
+s                    0x1bc952bd048dd38668a0c3b4bac202945c5a150465b551dd2a768e54a746e2c4
+to                   0x4200000000000000000000000000000000000010
+transactionIndex     0
+v                    875
+value                0
+index                2337598
+l1BlockNumber        7850866
+l1Timestamp          1666982083
+queueOrigin          sequencer
+rawTransaction       0xf901070a018301cdae94420000000000000000000000000000000000001080b8a432b7006d000000000000000000000000deaddeaddeaddeaddeaddeaddeaddeaddead000000000000000000000000000000000000000000000000000000005af3107a400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000082036ba07e58c5dbb37f57303d936562d89a75a20be2a45f54c5d44dc73119453adf2e08a01bc952bd048dd38668a0c3b4bac202945c5a150465b551dd2a768e54a746e2c4
+
+cast tx 0xd66fda632b51a8b25a9d260d70da8be57b9930c4616370861526335c3e8eef81 --rpc-url https://goerli.optimism.io
+
+blockHash               0x67956cee3de38d49206d34b77f560c4c371d77b36584047ade8bf7b67bf210c0
+blockNumber             2337599
+contractAddress
+cumulativeGasUsed       115390
+effectiveGasPrice
+gasUsed                 115390
+logs                    [{"address":"0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000","topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000001d86c2f5cc7fbec35fedbd3293b5004a841ea3f0","0x0000000000000000000000000000000000000000000000000000000000000000"],"data":"0x00000000000000000000000000000000000000000000000000005af3107a4000","blockHash":"0x67956cee3de38d49206d34b77f560c4c371d77b36584047ade8bf7b67bf210c0","blockNumber":"0x23ab3f","transactionHash":"0xd66fda632b51a8b25a9d260d70da8be57b9930c4616370861526335c3e8eef81","transactionIndex":"0x0","logIndex":"0x0","removed":false},{"address":"0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000","topics":["0xcc16f5dbb4873280815c1ee09dbd06736cffcc184412cf7a71a0fdb75d397ca5","0x0000000000000000000000001d86c2f5cc7fbec35fedbd3293b5004a841ea3f0"],"data":"0x00000000000000000000000000000000000000000000000000005af3107a4000","blockHash":"0x67956cee3de38d49206d34b77f560c4c371d77b36584047ade8bf7b67bf210c0","blockNumber":"0x23ab3f","transactionHash":"0xd66fda632b51a8b25a9d260d70da8be57b9930c4616370861526335c3e8eef81","transactionIndex":"0x0","logIndex":"0x1","removed":false},{"address":"0x4200000000000000000000000000000000000007","topics":["0xcb0f7ffd78f9aee47a248fae8db181db6eee833039123e026dcbff529522e52a","0x000000000000000000000000636af16bf2f682dd3109e60102b8e1a089fedaa8"],"data":"0x00000000000000000000000042000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000001a048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a41532ec340000000000000000000000001d86c2f5cc7fbec35fedbd3293b5004a841ea3f00000000000000000000000001d86c2f5cc7fbec35fedbd3293b5004a841ea3f000000000000000000000000000000000000000000000000000005af3107a40000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","blockHash":"0x67956cee3de38d49206d34b77f560c4c371d77b36584047ade8bf7b67bf210c0","blockNumber":"0x23ab3f","transactionHash":"0xd66fda632b51a8b25a9d260d70da8be57b9930c4616370861526335c3e8eef81","transactionIndex":"0x0","logIndex":"0x2","removed":false},{"address":"0x4200000000000000000000000000000000000010","topics":["0x73d170910aba9e6d50b102db522b1dbcd796216f5128b445aa2135272886497e","0x0000000000000000000000000000000000000000000000000000000000000000","0x000000000000000000000000deaddeaddeaddeaddeaddeaddeaddeaddead0000","0x0000000000000000000000001d86c2f5cc7fbec35fedbd3293b5004a841ea3f0"],"data":"0x0000000000000000000000001d86c2f5cc7fbec35fedbd3293b5004a841ea3f000000000000000000000000000000000000000000000000000005af3107a400000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000","blockHash":"0x67956cee3de38d49206d34b77f560c4c371d77b36584047ade8bf7b67bf210c0","blockNumber":"0x23ab3f","transactionHash":"0xd66fda632b51a8b25a9d260d70da8be57b9930c4616370861526335c3e8eef81","transactionIndex":"0x0","logIndex":"0x3","removed":false}]
+logsBloom               0x00000000000000000010000000000000000000000000001000100000001000000000000000000080000000000000008000000800000000000000000000000240000000002000400040000008000000000000000000000000000000000000000100000000020000000000000000000800080000000040000000000010000000000000000000000000000000000000000000800000000000000020000000200000000000000000000001000000000000000000200000000000000000000000000000000002000000200000000400000000000002100000000000000000000020001000000000000000000000000000000000000000000000000000010000008000
+root
+status                  1
+transactionHash         0xd66fda632b51a8b25a9d260d70da8be57b9930c4616370861526335c3e8eef81
+transactionIndex        0
+type
+ */
+const E2E_RPC_URL_L1 = z
+  .string()
+  .url()
+  .describe('L1 ethereum rpc Url')
+  .parse(import.meta.env.VITE_E2E_RPC_URL_L1)
+const E2E_RPC_URL_L2 = z
+  .string()
+  .url()
+  .describe('L1 ethereum rpc Url')
+  .parse(import.meta.env.VITE_E2E_RPC_URL_L2)
+const E2E_PRIVATE_KEY = z
+  .string()
+  .describe('Private key')
+  .parse(import.meta.env.VITE_E2E_PRIVATE_KEY)
+
+const jsonRpcHeaders = { 'User-Agent': 'eth-optimism/@gateway/backend' }
+/**
+ * Initialize the signer, prover, and cross chain messenger
+ */
+const l1Provider = new ethers.providers.JsonRpcProvider({
+  url: E2E_RPC_URL_L1,
+  headers: jsonRpcHeaders,
+})
+const l2Provider = new ethers.providers.JsonRpcProvider({
+  url: E2E_RPC_URL_L2,
+  headers: jsonRpcHeaders,
+})
+const l1Wallet = new ethers.Wallet(E2E_PRIVATE_KEY, l1Provider)
+const crossChainMessenger = new CrossChainMessenger({
+  l1SignerOrProvider: l1Wallet,
+  l2SignerOrProvider: l2Provider,
+  l1ChainId: 5,
+  l2ChainId: 420,
+  bedrock: true,
+})
+
+describe('prove message', () => {
+  it(`should prove a legacy tx
+  `, async () => {
+    /**
+     * Tx hash of legacy withdrawal
+     *
+     * @see https://goerli-optimism.etherscan.io/tx/0xd66fda632b51a8b25a9d260d70da8be57b9930c4616370861526335c3e8eef81
+     */
+    const txWithdrawalHash =
+      '0xd66fda632b51a8b25a9d260d70da8be57b9930c4616370861526335c3e8eef81'
+
+    const txReceipt = await l2Provider.getTransactionReceipt(txWithdrawalHash)
+
+    expect(txReceipt).toBeDefined()
+
+    const tx = await crossChainMessenger.proveMessage(txWithdrawalHash)
+    const receipt = await tx.wait()
+
+    // A 1 means the transaction was successful
+    expect(receipt.status).toBe(1)
+  }, 20_000)
+})

packages/sdk/test/utils/message-utils.spec.ts

 import { BigNumber } from 'ethers'
 
 import { expect } from '../setup'
-import { migratedWithdrawalGasLimit } from '../../src/utils/message-utils'
+import {
+  migratedWithdrawalGasLimit,
+  hashLowLevelMessage,
+  hashMessageHash,
+} from '../../src/utils/message-utils'
 
 describe('Message Utils', () => {
   describe('migratedWithdrawalGasLimit', () => {
@@ -26,4 +30,47 @@ describe('Message Utils', () => {
       }
     })
   })
+
+  /**
+   * Test that storage slot computation is correct. The test vectors are
+   * from actual migrated withdrawals on goerli.
+   */
+  describe('Withdrawal Hashing', () => {
+    it('should work', () => {
+      const tests = [
+        {
+          input: {
+            messageNonce: BigNumber.from(100000),
+            sender: '0x4200000000000000000000000000000000000007',
+            target: '0x5086d1eEF304eb5284A0f6720f79403b4e9bE294',
+            value: BigNumber.from(0),
+            minGasLimit: BigNumber.from(207744),
+            message:
+              '0xd764ad0b00000000000000000000000000000000000000000000000000000000000186a00000000000000000000000004200000000000000000000000000000000000010000000000000000000000000636af16bf2f682dd3109e60102b8e1a089fedaa80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000e4a9f9e67500000000000000000000000007865c6e87b9f70255377e024ace6630c1eaa37f0000000000000000000000003b8e53b3ab8e01fb57d0c9e893bc4d655aa67d84000000000000000000000000b91882244f7f82540f2941a759724523c7b9a166000000000000000000000000b91882244f7f82540f2941a759724523c7b9a166000000000000000000000000000000000000000000000000000000000000271000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+          },
+          result:
+            '0x7c83d39edf60c0ab61bc7cfd2e5f741efdf02fd6e2da0f12318f0d1858d3773b',
+        },
+        {
+          input: {
+            messageNonce: BigNumber.from(100001),
+            sender: '0x4200000000000000000000000000000000000007',
+            target: '0x5086d1eEF304eb5284A0f6720f79403b4e9bE294',
+            value: BigNumber.from(0),
+            minGasLimit: BigNumber.from(207744),
+            message:
+              '0xd764ad0b00000000000000000000000000000000000000000000000000000000000186a10000000000000000000000004200000000000000000000000000000000000010000000000000000000000000636af16bf2f682dd3109e60102b8e1a089fedaa80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000e4a9f9e67500000000000000000000000007865c6e87b9f70255377e024ace6630c1eaa37f0000000000000000000000004e62882864fb8ce54affcaf8d899a286762b011b000000000000000000000000b91882244f7f82540f2941a759724523c7b9a166000000000000000000000000b91882244f7f82540f2941a759724523c7b9a166000000000000000000000000000000000000000000000000000000000000271000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+          },
+          result:
+            '0x17c90d87508a23d806962f4c5f366ef505e8d80e5cc2a5c87242560c21d7c588',
+        },
+      ]
+
+      for (const test of tests) {
+        const hash = hashLowLevelMessage(test.input)
+        const messageSlot = hashMessageHash(hash)
+        expect(messageSlot).to.eq(test.result)
+      }
+    })
+  })
 })