Merge branch 'develop' into refcell/recent-game-loading

.changeset/hip-olives-press.md

----
-'@eth-optimism/sdk': patch
----
-
-Updated npm dependencies to latest

.changeset/tame-doors-invite.md

----
-'@eth-optimism/common-ts': patch
----
-
-Updated npm dependencies of common-ts

indexer/api/routes/deposits.go

@@ -46,7 +46,7 @@ func newDepositResponse(deposits *database.L1BridgeDepositsResponse) DepositResp
 			},
 			From:   deposit.L1BridgeDeposit.Tx.FromAddress.String(),
 			To:     deposit.L1BridgeDeposit.Tx.ToAddress.String(),
-			Amount: deposit.L1BridgeDeposit.Tx.Amount.Int.String(),
+			Amount: deposit.L1BridgeDeposit.Tx.Amount.String(),
 			L1Token: TokenInfo{
 				ChainId:  1,
 				Address:  deposit.L1BridgeDeposit.TokenPair.LocalTokenAddress.String(),

indexer/api/routes/withdrawals.go

@@ -60,7 +60,7 @@ func newWithdrawalResponse(withdrawals *database.L2BridgeWithdrawalsResponse) Wi
 			From:            withdrawal.L2BridgeWithdrawal.Tx.FromAddress.String(),
 			To:              withdrawal.L2BridgeWithdrawal.Tx.ToAddress.String(),
 			TransactionHash: withdrawal.L2TransactionHash.String(),
-			Amount:          withdrawal.L2BridgeWithdrawal.Tx.Amount.Int.String(),
+			Amount:          withdrawal.L2BridgeWithdrawal.Tx.Amount.String(),
 			Proof: Proof{
 				TransactionHash: withdrawal.ProvenL1TransactionHash.String(),
 				BlockTimestamp:  withdrawal.L2BridgeWithdrawal.Tx.Timestamp,

indexer/database/blocks.go

@@ -20,7 +20,7 @@ import (
 type BlockHeader struct {
 	Hash       common.Hash `gorm:"primaryKey;serializer:bytes"`
 	ParentHash common.Hash `gorm:"serializer:bytes"`
-	Number     U256
+	Number     *big.Int    `gorm:"serializer:u256"`
 	Timestamp  uint64
 
 	RLPHeader *RLPHeader `gorm:"serializer:rlp;column:rlp_bytes"`
@@ -30,7 +30,7 @@ func BlockHeaderFromHeader(header *types.Header) BlockHeader {
 	return BlockHeader{
 		Hash:       header.Hash(),
 		ParentHash: header.ParentHash,
-		Number:     U256{Int: header.Number},
+		Number:     header.Number,
 		Timestamp:  header.Time,
 
 		RLPHeader: (*RLPHeader)(header),
@@ -58,8 +58,8 @@ type LegacyStateBatch struct {
 
 type OutputProposal struct {
 	OutputRoot    common.Hash `gorm:"primaryKey;serializer:bytes"`
-	L2OutputIndex U256
-	L2BlockNumber U256
+	L2OutputIndex *big.Int    `gorm:"serializer:u256"`
+	L2BlockNumber *big.Int    `gorm:"serializer:u256"`
 
 	L1ContractEventGUID uuid.UUID
 }
@@ -165,7 +165,7 @@ func (db *blocksDB) LatestCheckpointedOutput() (*OutputProposal, error) {
 
 func (db *blocksDB) OutputProposal(index *big.Int) (*OutputProposal, error) {
 	var outputProposal OutputProposal
-	result := db.gorm.Where(&OutputProposal{L2OutputIndex: U256{Int: index}}).Take(&outputProposal)
+	result := db.gorm.Where(&OutputProposal{L2OutputIndex: index}).Take(&outputProposal)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return nil, nil

indexer/database/bridge_messages.go

@@ -3,6 +3,7 @@ package database
 import (
 	"errors"
 	"fmt"
+	"math/big"
 
 	"gorm.io/gorm"
 
@@ -17,13 +18,13 @@ import (
 
 type BridgeMessage struct {
 	MessageHash common.Hash `gorm:"primaryKey;serializer:bytes"`
-	Nonce       U256
+	Nonce       *big.Int    `gorm:"serializer:u256"`
 
 	SentMessageEventGUID    uuid.UUID
 	RelayedMessageEventGUID *uuid.UUID
 
 	Tx       Transaction `gorm:"embedded"`
-	GasLimit U256
+	GasLimit *big.Int    `gorm:"serializer:u256"`
 }
 
 type L1BridgeMessage struct {

indexer/database/bridge_transactions.go

@@ -3,6 +3,7 @@ package database
 import (
 	"errors"
 	"fmt"
+	"math/big"
 
 	"github.com/google/uuid"
 	"gorm.io/gorm"
@@ -17,8 +18,8 @@ import (
 type Transaction struct {
 	FromAddress common.Address `gorm:"serializer:bytes"`
 	ToAddress   common.Address `gorm:"serializer:bytes"`
-	Amount      U256
-	Data        Bytes `gorm:"serializer:bytes"`
+	Amount      *big.Int       `gorm:"serializer:u256"`
+	Data        Bytes          `gorm:"serializer:bytes"`
 	Timestamp   uint64
 }
 
@@ -28,12 +29,12 @@ type L1TransactionDeposit struct {
 	InitiatedL1EventGUID uuid.UUID
 
 	Tx       Transaction `gorm:"embedded"`
-	GasLimit U256
+	GasLimit *big.Int    `gorm:"serializer:u256"`
 }
 
 type L2TransactionWithdrawal struct {
 	WithdrawalHash       common.Hash `gorm:"serializer:bytes;primaryKey"`
-	Nonce                U256
+	Nonce                *big.Int    `gorm:"serializer:u256"`
 	InitiatedL2EventGUID uuid.UUID
 
 	ProvenL1EventGUID    *uuid.UUID
@@ -41,7 +42,7 @@ type L2TransactionWithdrawal struct {
 	Succeeded            *bool
 
 	Tx       Transaction `gorm:"embedded"`
-	GasLimit U256
+	GasLimit *big.Int    `gorm:"serializer:u256"`
 }
 
 type BridgeTransactionsView interface {

indexer/database/serializers/u256.go

+package serializers
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"reflect"
+
+	"github.com/jackc/pgtype"
+	"gorm.io/gorm/schema"
+)
+
+var (
+	big10              = big.NewInt(10)
+	u256BigIntOverflow = new(big.Int).Exp(big.NewInt(2), big.NewInt(256), nil)
+)
+
+type U256Serializer struct{}
+
+func init() {
+	schema.RegisterSerializer("u256", U256Serializer{})
+}
+
+func (U256Serializer) Scan(ctx context.Context, field *schema.Field, dst reflect.Value, dbValue interface{}) error {
+	if dbValue == nil {
+		return nil
+	} else if field.FieldType != reflect.TypeOf((*big.Int)(nil)) {
+		return fmt.Errorf("can only deserialize into a *big.Int: %T", field.FieldType)
+	}
+
+	numeric := new(pgtype.Numeric)
+	err := numeric.Scan(dbValue)
+	if err != nil {
+		return err
+	}
+
+	bigInt := numeric.Int
+	if numeric.Exp > 0 {
+		factor := new(big.Int).Exp(big10, big.NewInt(int64(numeric.Exp)), nil)
+		bigInt.Mul(bigInt, factor)
+	}
+
+	if bigInt.Cmp(u256BigIntOverflow) >= 0 {
+		return fmt.Errorf("deserialized number larger than u256 can hold: %s", bigInt)
+	}
+
+	field.ReflectValueOf(ctx, dst).Set(reflect.ValueOf(bigInt))
+	return nil
+}
+
+func (U256Serializer) Value(ctx context.Context, field *schema.Field, dst reflect.Value, fieldValue interface{}) (interface{}, error) {
+	if fieldValue == nil || (field.FieldType.Kind() == reflect.Pointer && reflect.ValueOf(fieldValue).IsNil()) {
+		return nil, nil
+	} else if field.FieldType != reflect.TypeOf((*big.Int)(nil)) {
+		return nil, fmt.Errorf("can only serialize a *big.Int: %T", field.FieldType)
+	}
+
+	numeric := pgtype.Numeric{Int: fieldValue.(*big.Int), Status: pgtype.Present}
+	return numeric.Value()
+}

indexer/database/types.go

 package database
 
 import (
-	"database/sql/driver"
-	"errors"
 	"io"
-	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/jackc/pgtype"
 )
 
-var u256BigIntOverflow = new(big.Int).Exp(big.NewInt(2), big.NewInt(256), nil)
-var big10 = big.NewInt(10)
-
-var ErrU256Overflow = errors.New("number exceeds u256")
-var ErrU256ContainsDecimal = errors.New("number contains fractional digits")
-var ErrU256Null = errors.New("number cannot be null")
-
-// U256 is a wrapper over big.Int that conforms to the database U256 numeric domain type
-type U256 struct {
-	Int *big.Int
-}
-
-// Scan implements the database/sql Scanner interface.
-func (u256 *U256) Scan(src interface{}) error {
-	// deserialize as a numeric
-	var numeric pgtype.Numeric
-	err := numeric.Scan(src)
-	if err != nil {
-		return err
-	} else if numeric.Exp < 0 {
-		return ErrU256ContainsDecimal
-	} else if numeric.Status == pgtype.Null {
-		return ErrU256Null
-	}
-
-	// factor in the powers of 10
-	num := numeric.Int
-	if numeric.Exp > 0 {
-		factor := new(big.Int).Exp(big10, big.NewInt(int64(numeric.Exp)), nil)
-		num.Mul(num, factor)
-	}
-
-	// check bounds before setting the u256
-	if num.Cmp(u256BigIntOverflow) >= 0 {
-		return ErrU256Overflow
-	} else {
-		u256.Int = num
-	}
-
-	return nil
-}
-
-// Value implements the database/sql/driver Valuer interface.
-func (u256 U256) Value() (driver.Value, error) {
-	// check bounds
-	if u256.Int == nil {
-		return nil, ErrU256Null
-	} else if u256.Int.Cmp(u256BigIntOverflow) >= 0 {
-		return nil, ErrU256Overflow
-	}
-
-	// simply encode as a numeric with no Exp set (non-decimal)
-	numeric := pgtype.Numeric{Int: u256.Int, Status: pgtype.Present}
-	return numeric.Value()
-}
+// Wrapper over types.Header such that we can get an RLP
+// encoder over it via a `types.Block` wrapper
 
 type RLPHeader types.Header
 
@@ -94,6 +37,9 @@ func (h *RLPHeader) Hash() common.Hash {
 	return h.Header().Hash()
 }
 
+// Type definition for []byte to conform to the
+// interface expected by the `bytes` serializer
+
 type Bytes []byte
 
 func (b Bytes) Bytes() []byte {

indexer/e2e_tests/bridge_messages_e2e_test.go

@@ -59,9 +59,9 @@ func TestE2EBridgeL1CrossDomainMessenger(t *testing.T) {
 	require.NotNil(t, sentMessage)
 	require.NotNil(t, sentMessage.SentMessageEventGUID)
 	require.Equal(t, depositInfo.DepositTx.SourceHash, sentMessage.TransactionSourceHash)
-	require.Equal(t, nonce.Uint64(), sentMessage.Nonce.Int.Uint64())
-	require.Equal(t, uint64(100_000), sentMessage.GasLimit.Int.Uint64())
-	require.Equal(t, big.NewInt(params.Ether), sentMessage.Tx.Amount.Int)
+	require.Equal(t, nonce.Uint64(), sentMessage.Nonce.Uint64())
+	require.Equal(t, uint64(100_000), sentMessage.GasLimit.Uint64())
+	require.Equal(t, uint64(params.Ether), sentMessage.Tx.Amount.Uint64())
 	require.Equal(t, aliceAddr, sentMessage.Tx.FromAddress)
 	require.Equal(t, aliceAddr, sentMessage.Tx.ToAddress)
 	require.ElementsMatch(t, calldata, sentMessage.Tx.Data)
@@ -146,9 +146,9 @@ func TestE2EBridgeL2CrossDomainMessenger(t *testing.T) {
 	require.NotNil(t, sentMessage)
 	require.NotNil(t, sentMessage.SentMessageEventGUID)
 	require.Equal(t, withdrawalHash, sentMessage.TransactionWithdrawalHash)
-	require.Equal(t, nonce.Uint64(), sentMessage.Nonce.Int.Uint64())
-	require.Equal(t, uint64(100_000), sentMessage.GasLimit.Int.Uint64())
-	require.Equal(t, big.NewInt(params.Ether), sentMessage.Tx.Amount.Int)
+	require.Equal(t, nonce.Uint64(), sentMessage.Nonce.Uint64())
+	require.Equal(t, uint64(100_000), sentMessage.GasLimit.Uint64())
+	require.Equal(t, uint64(params.Ether), sentMessage.Tx.Amount.Uint64())
 	require.Equal(t, aliceAddr, sentMessage.Tx.FromAddress)
 	require.Equal(t, aliceAddr, sentMessage.Tx.ToAddress)
 	require.ElementsMatch(t, calldata, sentMessage.Tx.Data)

indexer/e2e_tests/bridge_transactions_e2e_test.go

@@ -54,8 +54,8 @@ func TestE2EBridgeTransactionsOptimismPortalDeposits(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, deposit)
 	require.Equal(t, depositL2TxHash, deposit.L2TransactionHash)
-	require.Equal(t, big.NewInt(100_000), deposit.GasLimit.Int)
-	require.Equal(t, big.NewInt(params.Ether), deposit.Tx.Amount.Int)
+	require.Equal(t, uint64(100_000), deposit.GasLimit.Uint64())
+	require.Equal(t, uint64(params.Ether), deposit.Tx.Amount.Uint64())
 	require.Equal(t, aliceAddr, deposit.Tx.FromAddress)
 	require.Equal(t, aliceAddr, deposit.Tx.ToAddress)
 	require.ElementsMatch(t, calldata, deposit.Tx.Data)
@@ -113,9 +113,9 @@ func TestE2EBridgeTransactionsL2ToL1MessagePasserWithdrawal(t *testing.T) {
 	withdraw, err := testSuite.DB.BridgeTransactions.L2TransactionWithdrawal(withdrawalHash)
 	require.NoError(t, err)
 	require.NotNil(t, withdraw)
-	require.Equal(t, msgPassed.Nonce.Uint64(), withdraw.Nonce.Int.Uint64())
-	require.Equal(t, big.NewInt(100_000), withdraw.GasLimit.Int)
-	require.Equal(t, big.NewInt(params.Ether), withdraw.Tx.Amount.Int)
+	require.Equal(t, msgPassed.Nonce.Uint64(), withdraw.Nonce.Uint64())
+	require.Equal(t, uint64(100_000), withdraw.GasLimit.Uint64())
+	require.Equal(t, uint64(params.Ether), withdraw.Tx.Amount.Uint64())
 	require.Equal(t, aliceAddr, withdraw.Tx.FromAddress)
 	require.Equal(t, aliceAddr, withdraw.Tx.ToAddress)
 	require.ElementsMatch(t, calldata, withdraw.Tx.Data)

indexer/e2e_tests/bridge_transfers_e2e_test.go

@@ -63,7 +63,7 @@ func TestE2EBridgeTransfersStandardBridgeETHDeposit(t *testing.T) {
 	require.Equal(t, depositInfo.DepositTx.SourceHash, deposit.TransactionSourceHash)
 	require.Equal(t, predeploys.LegacyERC20ETHAddr, deposit.TokenPair.LocalTokenAddress)
 	require.Equal(t, predeploys.LegacyERC20ETHAddr, deposit.TokenPair.RemoteTokenAddress)
-	require.Equal(t, big.NewInt(params.Ether), deposit.Tx.Amount.Int)
+	require.Equal(t, uint64(params.Ether), deposit.Tx.Amount.Uint64())
 	require.Equal(t, aliceAddr, deposit.Tx.FromAddress)
 	require.Equal(t, aliceAddr, deposit.Tx.ToAddress)
 	require.Equal(t, byte(1), deposit.Tx.Data[0])
@@ -227,13 +227,15 @@ func TestE2EBridgeTransfersOptimismPortalETHReceive(t *testing.T) {
 
 	aliceDeposits, err := testSuite.DB.BridgeTransfers.L1BridgeDepositsByAddress(aliceAddr, "", 0)
 	require.NoError(t, err)
+	require.NotNil(t, aliceDeposits)
+	require.Len(t, aliceDeposits.Deposits, 1)
 	require.Equal(t, portalDepositTx.Hash(), aliceDeposits.Deposits[0].L1TransactionHash)
 
 	deposit := aliceDeposits.Deposits[0].L1BridgeDeposit
 	require.Equal(t, depositInfo.DepositTx.SourceHash, deposit.TransactionSourceHash)
 	require.Equal(t, predeploys.LegacyERC20ETHAddr, deposit.TokenPair.LocalTokenAddress)
 	require.Equal(t, predeploys.LegacyERC20ETHAddr, deposit.TokenPair.RemoteTokenAddress)
-	require.Equal(t, big.NewInt(params.Ether), deposit.Tx.Amount.Int)
+	require.Equal(t, uint64(params.Ether), deposit.Tx.Amount.Uint64())
 	require.Equal(t, aliceAddr, deposit.Tx.FromAddress)
 	require.Equal(t, aliceAddr, deposit.Tx.ToAddress)
 	require.Len(t, deposit.Tx.Data, 0)
@@ -304,7 +306,7 @@ func TestE2EBridgeTransfersStandardBridgeETHWithdrawal(t *testing.T) {
 	require.Equal(t, withdrawalHash, withdrawal.TransactionWithdrawalHash)
 	require.Equal(t, predeploys.LegacyERC20ETHAddr, withdrawal.TokenPair.LocalTokenAddress)
 	require.Equal(t, predeploys.LegacyERC20ETHAddr, withdrawal.TokenPair.RemoteTokenAddress)
-	require.Equal(t, big.NewInt(params.Ether), withdrawal.Tx.Amount.Int)
+	require.Equal(t, uint64(params.Ether), withdrawal.Tx.Amount.Uint64())
 	require.Equal(t, aliceAddr, withdrawal.Tx.FromAddress)
 	require.Equal(t, aliceAddr, withdrawal.Tx.ToAddress)
 	require.Equal(t, byte(1), withdrawal.Tx.Data[0])
@@ -339,7 +341,7 @@ func TestE2EBridgeTransfersStandardBridgeETHWithdrawal(t *testing.T) {
 	require.NotNil(t, crossDomainBridgeMessage.RelayedMessageEventGUID)
 }
 
-func TestE2EBridgeTransfersL2ToL1MessagePasserReceive(t *testing.T) {
+func TestE2EBridgeTransfersL2ToL1MessagePasserETHReceive(t *testing.T) {
 	testSuite := createE2ETestSuite(t)
 
 	optimismPortal, err := bindings.NewOptimismPortal(testSuite.OpCfg.L1Deployments.OptimismPortalProxy, testSuite.L1Client)
@@ -376,6 +378,7 @@ func TestE2EBridgeTransfersL2ToL1MessagePasserReceive(t *testing.T) {
 
 	aliceWithdrawals, err := testSuite.DB.BridgeTransfers.L2BridgeWithdrawalsByAddress(aliceAddr, "", 0)
 	require.NoError(t, err)
+	require.Len(t, aliceWithdrawals.Withdrawals, 1)
 	require.Equal(t, l2ToL1MessagePasserWithdrawTx.Hash().String(), aliceWithdrawals.Withdrawals[0].L2TransactionHash.String())
 
 	msgPassed, err := withdrawals.ParseMessagePassed(l2ToL1WithdrawReceipt)
@@ -387,7 +390,7 @@ func TestE2EBridgeTransfersL2ToL1MessagePasserReceive(t *testing.T) {
 	require.Equal(t, withdrawalHash, withdrawal.TransactionWithdrawalHash)
 	require.Equal(t, predeploys.LegacyERC20ETHAddr, withdrawal.TokenPair.LocalTokenAddress)
 	require.Equal(t, predeploys.LegacyERC20ETHAddr, withdrawal.TokenPair.RemoteTokenAddress)
-	require.Equal(t, big.NewInt(params.Ether), withdrawal.Tx.Amount.Int)
+	require.Equal(t, uint64(params.Ether), withdrawal.Tx.Amount.Uint64())
 	require.Equal(t, aliceAddr, withdrawal.Tx.FromAddress)
 	require.Equal(t, aliceAddr, withdrawal.Tx.ToAddress)
 	require.Len(t, withdrawal.Tx.Data, 0)

indexer/e2e_tests/etl_e2e_test.go

@@ -40,19 +40,19 @@ func TestE2EETL(t *testing.T) {
 		l2Header, err := testSuite.DB.Blocks.L2LatestBlockHeader()
 		require.NoError(t, err)
 
-		return (l1Header != nil && l1Header.Number.Int.Uint64() >= l1Height) && (l2Header != nil && l2Header.Number.Int.Uint64() >= 9), nil
+		return (l1Header != nil && l1Header.Number.Uint64() >= l1Height) && (l2Header != nil && l2Header.Number.Uint64() >= 9), nil
 	}))
 
 	t.Run("indexes all L2 blocks", func(t *testing.T) {
 		latestL2Header, err := testSuite.DB.Blocks.L2LatestBlockHeader()
 		require.NoError(t, err)
 		require.NotNil(t, latestL2Header)
-		require.True(t, latestL2Header.Number.Int.Uint64() >= 9)
+		require.True(t, latestL2Header.Number.Uint64() >= 9)
 
 		for i := int64(0); i < 10; i++ {
 			height := big.NewInt(i)
 
-			indexedHeader, err := testSuite.DB.Blocks.L2BlockHeaderWithFilter(database.BlockHeader{Number: database.U256{Int: height}})
+			indexedHeader, err := testSuite.DB.Blocks.L2BlockHeaderWithFilter(database.BlockHeader{Number: height})
 			require.NoError(t, err)
 			require.NotNil(t, indexedHeader)
 
@@ -60,7 +60,7 @@ func TestE2EETL(t *testing.T) {
 			require.NoError(t, err)
 			require.NotNil(t, indexedHeader)
 
-			require.Equal(t, header.Number.Int64(), indexedHeader.Number.Int.Int64())
+			require.Equal(t, header.Number.Int64(), indexedHeader.Number.Int64())
 			require.Equal(t, header.Hash(), indexedHeader.Hash)
 			require.Equal(t, header.ParentHash, indexedHeader.ParentHash)
 			require.Equal(t, header.Time, indexedHeader.Timestamp)
@@ -144,7 +144,7 @@ func TestE2EETL(t *testing.T) {
 			require.NoError(t, err)
 			require.Equal(t, block.Hash(), l1BlockHeader.Hash)
 			require.Equal(t, block.ParentHash(), l1BlockHeader.ParentHash)
-			require.Equal(t, block.Number(), l1BlockHeader.Number.Int)
+			require.Equal(t, block.Number().Uint64(), l1BlockHeader.Number.Uint64())
 			require.Equal(t, block.Time(), l1BlockHeader.Timestamp)
 
 			// ensure the right rlp encoding is stored. checking the hashes

indexer/etl/l1_etl.go

@@ -38,7 +38,7 @@ func NewL1ETL(log log.Logger, db *database.DB, client node.EthClient, startHeigh
 	// Determine the starting height for traversal
 	var fromHeader *types.Header
 	if latestHeader != nil {
-		log.Info("detected last indexed block", "number", latestHeader.Number.Int, "hash", latestHeader.Hash)
+		log.Info("detected last indexed block", "number", latestHeader.Number, "hash", latestHeader.Hash)
 		fromHeader = latestHeader.RLPHeader.Header()
 
 	} else if startHeight.BitLen() > 0 {

indexer/etl/l2_etl.go

@@ -35,7 +35,7 @@ func NewL2ETL(log log.Logger, db *database.DB, client node.EthClient) (*L2ETL, e
 
 	var fromHeader *types.Header
 	if latestHeader != nil {
-		log.Info("detected last indexed block", "number", latestHeader.Number.Int, "hash", latestHeader.Hash)
+		log.Info("detected last indexed block", "number", latestHeader.Number, "hash", latestHeader.Hash)
 		fromHeader = latestHeader.RLPHeader.Header()
 	} else {
 		log.Info("no indexed state, starting from genesis")

indexer/migrations/20230523_create_schema.sql

@@ -184,11 +184,8 @@ CREATE TABLE IF NOT EXISTS l2_bridge_messages(
 
 -- StandardBridge
 CREATE TABLE IF NOT EXISTS l1_bridge_deposits (
-    transaction_source_hash VARCHAR PRIMARY KEY REFERENCES l1_transaction_deposits(source_hash),
-
-    -- We allow the cross_domain_message_hash to be NULL-able to account
-    -- for scenarios where ETH is simply sent to the OptimismPortal contract
-    cross_domain_message_hash VARCHAR UNIQUE REFERENCES l1_bridge_messages(message_hash),
+    transaction_source_hash   VARCHAR PRIMARY KEY REFERENCES l1_transaction_deposits(source_hash),
+    cross_domain_message_hash VARCHAR NOT NULL UNIQUE REFERENCES l1_bridge_messages(message_hash),
 
     -- Deposit information
 	from_address         VARCHAR NOT NULL,
@@ -201,10 +198,7 @@ CREATE TABLE IF NOT EXISTS l1_bridge_deposits (
 );
 CREATE TABLE IF NOT EXISTS l2_bridge_withdrawals (
     transaction_withdrawal_hash VARCHAR PRIMARY KEY REFERENCES l2_transaction_withdrawals(withdrawal_hash),
-
-    -- We allow the cross_domain_message_hash to be NULL-able to account for
-    -- scenarios where ETH is simply sent to the L2ToL1MessagePasser contract
-    cross_domain_message_hash VARCHAR UNIQUE REFERENCES l2_bridge_messages(message_hash),
+    cross_domain_message_hash   VARCHAR NOT NULL UNIQUE REFERENCES l2_bridge_messages(message_hash),
 
     -- Withdrawal information
 	from_address         VARCHAR NOT NULL,

indexer/processors/bridge.go

@@ -107,7 +107,7 @@ func (b *BridgeProcessor) Start(ctx context.Context) error {
 				continue
 			}
 
-			toL1Height, toL2Height := latestEpoch.L1BlockHeader.Number.Int, latestEpoch.L2BlockHeader.Number.Int
+			toL1Height, toL2Height := latestEpoch.L1BlockHeader.Number, latestEpoch.L2BlockHeader.Number
 			fromL1Height, fromL2Height := big.NewInt(0), big.NewInt(0)
 			if b.LatestL1Header != nil {
 				// `NewBridgeProcessor` ensures that LatestL2Header must not be nil if LatestL1Header is set

indexer/processors/bridge/l1_bridge_processor.go

@@ -26,7 +26,6 @@ func L1ProcessInitiatedBridgeEvents(log log.Logger, db *database.DB, chainConfig
 		return err
 	}
 
-	ethDeposits := []database.L1BridgeDeposit{}
 	portalDeposits := make(map[logKey]*contracts.OptimismPortalTransactionDepositEvent, len(optimismPortalTxDeposits))
 	transactionDeposits := make([]database.L1TransactionDeposit, len(optimismPortalTxDeposits))
 	for i := range optimismPortalTxDeposits {
@@ -39,14 +38,6 @@ func L1ProcessInitiatedBridgeEvents(log log.Logger, db *database.DB, chainConfig
 			GasLimit:             depositTx.GasLimit,
 			Tx:                   depositTx.Tx,
 		}
-
-		// catch ETH transfers to the portal contract.
-		if len(depositTx.DepositTx.Data) == 0 && depositTx.DepositTx.Value.BitLen() > 0 {
-			ethDeposits = append(ethDeposits, database.L1BridgeDeposit{
-				TransactionSourceHash: depositTx.DepositTx.SourceHash,
-				BridgeTransfer:        database.BridgeTransfer{Tx: transactionDeposits[i].Tx, TokenPair: database.ETHTokenPair},
-			})
-		}
 	}
 
 	if len(transactionDeposits) > 0 {
@@ -54,12 +45,6 @@ func L1ProcessInitiatedBridgeEvents(log log.Logger, db *database.DB, chainConfig
 		if err := db.BridgeTransactions.StoreL1TransactionDeposits(transactionDeposits); err != nil {
 			return err
 		}
-		if len(ethDeposits) > 0 {
-			log.Info("detected portal ETH transfers", "size", len(ethDeposits))
-			if err := db.BridgeTransfers.StoreL1BridgeDeposits(ethDeposits); err != nil {
-				return err
-			}
-		}
 	}
 
 	// (2) L1CrossDomainMessenger

indexer/processors/bridge/l2_bridge_processor.go

@@ -26,7 +26,6 @@ func L2ProcessInitiatedBridgeEvents(log log.Logger, db *database.DB, fromHeight
 		return err
 	}
 
-	ethWithdrawals := []database.L2BridgeWithdrawal{}
 	messagesPassed := make(map[logKey]*contracts.L2ToL1MessagePasserMessagePassed, len(l2ToL1MPMessagesPassed))
 	transactionWithdrawals := make([]database.L2TransactionWithdrawal, len(l2ToL1MPMessagesPassed))
 	for i := range l2ToL1MPMessagesPassed {
@@ -39,13 +38,6 @@ func L2ProcessInitiatedBridgeEvents(log log.Logger, db *database.DB, fromHeight
 			GasLimit:             messagePassed.GasLimit,
 			Tx:                   messagePassed.Tx,
 		}
-
-		if len(messagePassed.Tx.Data) == 0 && messagePassed.Tx.Amount.Int.BitLen() > 0 {
-			ethWithdrawals = append(ethWithdrawals, database.L2BridgeWithdrawal{
-				TransactionWithdrawalHash: messagePassed.WithdrawalHash,
-				BridgeTransfer:            database.BridgeTransfer{Tx: transactionWithdrawals[i].Tx, TokenPair: database.ETHTokenPair},
-			})
-		}
 	}
 
 	if len(messagesPassed) > 0 {
@@ -53,12 +45,6 @@ func L2ProcessInitiatedBridgeEvents(log log.Logger, db *database.DB, fromHeight
 		if err := db.BridgeTransactions.StoreL2TransactionWithdrawals(transactionWithdrawals); err != nil {
 			return err
 		}
-		if len(ethWithdrawals) > 0 {
-			log.Info("detected L2ToL1MessagePasser ETH transfers", "size", len(ethWithdrawals))
-			if err := db.BridgeTransfers.StoreL2BridgeWithdrawals(ethWithdrawals); err != nil {
-				return err
-			}
-		}
 	}
 
 	// (2) L2CrossDomainMessenger

indexer/processors/contracts/cross_domain_messenger.go

@@ -94,13 +94,13 @@ func CrossDomainMessengerSentMessageEvents(chainSelector string, contractAddress
 			Event: &sentMessageEvents[i],
 			BridgeMessage: database.BridgeMessage{
 				MessageHash:          messageHash,
-				Nonce:                database.U256{Int: sentMessage.MessageNonce},
+				Nonce:                sentMessage.MessageNonce,
 				SentMessageEventGUID: sentMessageEvents[i].GUID,
-				GasLimit:             database.U256{Int: sentMessage.GasLimit},
+				GasLimit:             sentMessage.GasLimit,
 				Tx: database.Transaction{
 					FromAddress: sentMessage.Sender,
 					ToAddress:   sentMessage.Target,
-					Amount:      database.U256{Int: sentMessageExtension.Value},
+					Amount:      sentMessageExtension.Value,
 					Data:        sentMessage.Message,
 					Timestamp:   sentMessageEvents[i].Timestamp,
 				},

indexer/processors/contracts/l2_to_l1_message_passer.go

@@ -11,8 +11,8 @@ import (
 type L2ToL1MessagePasserMessagePassed struct {
 	Event          *database.ContractEvent
 	WithdrawalHash common.Hash
-	GasLimit       database.U256
-	Nonce          database.U256
+	GasLimit       *big.Int
+	Nonce          *big.Int
 	Tx             database.Transaction
 }
 
@@ -40,12 +40,12 @@ func L2ToL1MessagePasserMessagePassedEvents(contractAddress common.Address, db *
 		messagesPassed[i] = L2ToL1MessagePasserMessagePassed{
 			Event:          &messagePassedEvents[i].ContractEvent,
 			WithdrawalHash: messagePassed.WithdrawalHash,
-			Nonce:          database.U256{Int: messagePassed.Nonce},
-			GasLimit:       database.U256{Int: messagePassed.GasLimit},
+			Nonce:          messagePassed.Nonce,
+			GasLimit:       messagePassed.GasLimit,
 			Tx: database.Transaction{
 				FromAddress: messagePassed.Sender,
 				ToAddress:   messagePassed.Target,
-				Amount:      database.U256{Int: messagePassed.Value},
+				Amount:      messagePassed.Value,
 				Data:        messagePassed.Data,
 				Timestamp:   messagePassedEvents[i].Timestamp,
 			},

indexer/processors/contracts/optimism_portal.go

@@ -16,7 +16,7 @@ type OptimismPortalTransactionDepositEvent struct {
 	Event     *database.ContractEvent
 	DepositTx *types.DepositTx
 	Tx        database.Transaction
-	GasLimit  database.U256
+	GasLimit  *big.Int
 }
 
 type OptimismPortalWithdrawalProvenEvent struct {
@@ -67,11 +67,11 @@ func OptimismPortalTransactionDepositEvents(contractAddress common.Address, db *
 		optimismPortalTxDeposits[i] = OptimismPortalTransactionDepositEvent{
 			Event:     &transactionDepositEvents[i].ContractEvent,
 			DepositTx: depositTx,
-			GasLimit:  database.U256{Int: new(big.Int).SetUint64(depositTx.Gas)},
+			GasLimit:  new(big.Int).SetUint64(depositTx.Gas),
 			Tx: database.Transaction{
 				FromAddress: txDeposit.From,
 				ToAddress:   txDeposit.To,
-				Amount:      database.U256{Int: depositTx.Value},
+				Amount:      depositTx.Value,
 				Data:        depositTx.Data,
 				Timestamp:   transactionDepositEvents[i].Timestamp,
 			},

indexer/processors/contracts/standard_bridge.go

@@ -101,7 +101,7 @@ func _standardBridgeInitiatedEvents[BridgeEventType bindings.StandardBridgeETHBr
 				Tx: database.Transaction{
 					FromAddress: erc20Bridge.From,
 					ToAddress:   erc20Bridge.To,
-					Amount:      database.U256{Int: erc20Bridge.Amount},
+					Amount:      erc20Bridge.Amount,
 					Data:        erc20Bridge.ExtraData,
 					Timestamp:   initiatedBridgeEvents[i].Timestamp,
 				},
@@ -161,7 +161,7 @@ func _standardBridgeFinalizedEvents[BridgeEventType bindings.StandardBridgeETHBr
 				Tx: database.Transaction{
 					FromAddress: erc20Bridge.From,
 					ToAddress:   erc20Bridge.To,
-					Amount:      database.U256{Int: erc20Bridge.Amount},
+					Amount:      erc20Bridge.Amount,
 					Data:        erc20Bridge.ExtraData,
 					Timestamp:   bridgeFinalizedEvents[i].Timestamp,
 				},

op-challenger/fault/cannon/provider.go

@@ -118,6 +118,10 @@ func (p *CannonTraceProvider) AbsolutePreState(ctx context.Context) ([]byte, err
 	return state.EncodeWitness(), nil
 }
 
+func (p *CannonTraceProvider) Cleanup() error {
+	return os.RemoveAll(p.dir)
+}
+
 // loadProof will attempt to load or generate the proof data at the specified index
 // If the requested index is beyond the end of the actual trace it is extended with no-op instructions.
 func (p *CannonTraceProvider) loadProof(ctx context.Context, i uint64) (*proofData, error) {

op-challenger/fault/cannon/provider_test.go

@@ -204,6 +204,14 @@ func TestUseGameSpecificSubdir(t *testing.T) {
 	require.Equal(t, filepath.Join(dataDir, gameDirName), provider.dir, "should use game specific subdir")
 }
 
+func TestCleanup(t *testing.T) {
+	dataDir, prestate := setupTestData(t)
+	provider, _ := setupWithTestData(t, dataDir, prestate)
+	require.NoError(t, provider.Cleanup())
+	_, err := os.Stat(dataDir)
+	require.ErrorIs(t, err, os.ErrNotExist)
+}
+
 func setupPreState(t *testing.T, dataDir string, filename string) {
 	srcDir := filepath.Join("test_data")
 	path := filepath.Join(srcDir, filename)

op-challenger/fault/player.go

@@ -29,6 +29,7 @@ type GamePlayer struct {
 	agreeWithProposedOutput bool
 	caller                  GameInfo
 	logger                  log.Logger
+	cleanup                 func() error
 }
 
 func NewGamePlayer(
@@ -54,18 +55,22 @@ func NewGamePlayer(
 
 	var provider types.TraceProvider
 	var updater types.OracleUpdater
+	var cleanup func() error
 	switch cfg.TraceType {
 	case config.TraceTypeCannon:
-		provider, err = cannon.NewTraceProvider(ctx, logger, cfg, client, addr)
+		cannonProvider, err := cannon.NewTraceProvider(ctx, logger, cfg, client, addr)
 		if err != nil {
 			return nil, fmt.Errorf("create cannon trace provider: %w", err)
 		}
+		cleanup = cannonProvider.Cleanup
+		provider = cannonProvider
 		updater, err = cannon.NewOracleUpdater(ctx, logger, txMgr, addr, client)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create the cannon updater: %w", err)
 		}
 	case config.TraceTypeAlphabet:
 		provider = alphabet.NewTraceProvider(cfg.AlphabetTrace, gameDepth)
+		cleanup = func() error { return nil }
 		updater = alphabet.NewOracleUpdater(logger)
 	default:
 		return nil, fmt.Errorf("unsupported trace type: %v", cfg.TraceType)
@@ -90,6 +95,7 @@ func NewGamePlayer(
 		agreeWithProposedOutput: cfg.AgreeWithProposedOutput,
 		caller:                  caller,
 		logger:                  logger,
+		cleanup:                 cleanup,
 	}, nil
 }
 
@@ -129,3 +135,7 @@ func (g *GamePlayer) logGameStatus(ctx context.Context, status types.GameStatus)
 		g.logger.Error("Game lost", "status", status)
 	}
 }
+
+func (g *GamePlayer) Cleanup() error {
+	return g.cleanup()
+}

op-challenger/fault/player_test.go

@@ -27,6 +27,24 @@ func TestProgressGame_LogErrorFromAct(t *testing.T) {
 	require.Equal(t, uint64(1), msg.GetContextValue("claims"))
 }
 
+func TestCleanup(t *testing.T) {
+	t.Run("default cleanup", func(t *testing.T) {
+		game := &GamePlayer{
+			cleanup: func() error { return nil },
+		}
+		require.NoError(t, game.Cleanup())
+	})
+
+	t.Run("cleanup bubbles up error", func(t *testing.T) {
+		err := errors.New("wassie")
+		game := &GamePlayer{
+			cleanup: func() error { return err },
+		}
+		require.Error(t, err, game.Cleanup())
+	})
+
+}
+
 func TestProgressGame_LogGameStatus(t *testing.T) {
 	tests := []struct {
 		name            string

op-node/rollup/types.go

@@ -139,7 +139,7 @@ type L1Client interface {
 func (cfg *Config) CheckL1ChainID(ctx context.Context, client L1Client) error {
 	id, err := client.ChainID(ctx)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get L1 chain ID: %w", err)
 	}
 	if cfg.L1ChainID.Cmp(id) != 0 {
 		return fmt.Errorf("incorrect L1 RPC chain id %d, expected %d", id, cfg.L1ChainID)
@@ -151,7 +151,7 @@ func (cfg *Config) CheckL1ChainID(ctx context.Context, client L1Client) error {
 func (cfg *Config) CheckL1GenesisBlockHash(ctx context.Context, client L1Client) error {
 	l1GenesisBlockRef, err := client.L1BlockRefByNumber(ctx, cfg.Genesis.L1.Number)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get L1 genesis blockhash: %w", err)
 	}
 	if l1GenesisBlockRef.Hash != cfg.Genesis.L1.Hash {
 		return fmt.Errorf("incorrect L1 genesis block hash %s, expected %s", l1GenesisBlockRef.Hash, cfg.Genesis.L1.Hash)
@@ -168,7 +168,7 @@ type L2Client interface {
 func (cfg *Config) CheckL2ChainID(ctx context.Context, client L2Client) error {
 	id, err := client.ChainID(ctx)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get L2 chain ID: %w", err)
 	}
 	if cfg.L2ChainID.Cmp(id) != 0 {
 		return fmt.Errorf("incorrect L2 RPC chain id %d, expected %d", id, cfg.L2ChainID)
@@ -180,7 +180,7 @@ func (cfg *Config) CheckL2ChainID(ctx context.Context, client L2Client) error {
 func (cfg *Config) CheckL2GenesisBlockHash(ctx context.Context, client L2Client) error {
 	l2GenesisBlockRef, err := client.L2BlockRefByNumber(ctx, cfg.Genesis.L2.Number)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get L2 genesis blockhash: %w", err)
 	}
 	if l2GenesisBlockRef.Hash != cfg.Genesis.L2.Hash {
 		return fmt.Errorf("incorrect L2 genesis block hash %s, expected %s", l2GenesisBlockRef.Hash, cfg.Genesis.L2.Hash)

package.json

@@ -68,7 +68,7 @@
     "markdownlint-cli2": "0.4.0",
     "mkdirp": "^1.0.4",
     "mocha": "^10.2.0",
-    "nx": "16.7.2",
+    "nx": "16.7.3",
     "nyc": "^15.1.0",
     "patch-package": "^8.0.0",
     "prettier": "^2.8.0",

packages/chain-mon/CHANGELOG.md

 # @eth-optimism/drippie-mon
 
+## 0.4.4
+
+### Patch Changes
+
+- Updated dependencies [[`9c3a03855`](https://github.com/ethereum-optimism/optimism/commit/9c3a03855dc982f0b4e1d664e83271883536632b), [`33eb63b10`](https://github.com/ethereum-optimism/optimism/commit/33eb63b10559a2267c814eda8129447c72940839)]:
+  - @eth-optimism/sdk@3.1.2
+  - @eth-optimism/common-ts@0.8.5
+
 ## 0.4.3
 
 ### Patch Changes

packages/chain-mon/package.json

 {
   "private": true,
   "name": "@eth-optimism/chain-mon",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "[Optimism] Chain monitoring services",
   "main": "dist/index",
   "types": "dist/index",

packages/common-ts/CHANGELOG.md

 # @eth-optimism/common-ts
 
+## 0.8.5
+
+### Patch Changes
+
+- [#6887](https://github.com/ethereum-optimism/optimism/pull/6887) [`33eb63b10`](https://github.com/ethereum-optimism/optimism/commit/33eb63b10559a2267c814eda8129447c72940839) Thanks [@roninjin10](https://github.com/roninjin10)! - Updated npm dependencies of common-ts
+
 ## 0.8.4
 
 ### Patch Changes

packages/common-ts/package.json

 {
   "name": "@eth-optimism/common-ts",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "[Optimism] Advanced typescript tooling used by various services",
   "main": "dist/index",
   "types": "dist/index",

packages/sdk/CHANGELOG.md

 # @eth-optimism/sdk
 
+## 3.1.2
+
+### Patch Changes
+
+- [#6886](https://github.com/ethereum-optimism/optimism/pull/6886) [`9c3a03855`](https://github.com/ethereum-optimism/optimism/commit/9c3a03855dc982f0b4e1d664e83271883536632b) Thanks [@roninjin10](https://github.com/roninjin10)! - Updated npm dependencies to latest
+
 ## 3.1.1
 
 ### Patch Changes

packages/sdk/package.json

 {
   "name": "@eth-optimism/sdk",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "[Optimism] Tools for working with Optimism",
   "main": "dist/index",
   "types": "dist/index",