Merge branch 'develop' into dependabot/npm_and_yarn/nx-16.7.3

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])
@@ -235,7 +235,7 @@ func TestE2EBridgeTransfersOptimismPortalETHReceive(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.Len(t, deposit.Tx.Data, 0)
@@ -306,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])
@@ -390,7 +390,7 @@ func TestE2EBridgeTransfersL2ToL1MessagePasserETHReceive(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/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/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