l1_bridge_processor.go 11.6 KB
Newer Older
1 2 3 4 5 6
package bridge

import (
	"fmt"
	"math/big"

7
	"github.com/ethereum-optimism/optimism/indexer/bigint"
8 9
	"github.com/ethereum-optimism/optimism/indexer/config"
	"github.com/ethereum-optimism/optimism/indexer/database"
10
	"github.com/ethereum-optimism/optimism/indexer/processors/contracts"
11

Hamdi Allam's avatar
Hamdi Allam committed
12
	"github.com/ethereum/go-ethereum/common"
13 14 15 16
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/log"
)

17
// L1ProcessInitiatedBridgeEvents will query the database for bridge events that have been initiated between
18 19 20 21
// the specified block range. This covers every part of the multi-layered stack:
//  1. OptimismPortal
//  2. L1CrossDomainMessenger
//  3. L1StandardBridge
Hamdi Allam's avatar
Hamdi Allam committed
22
func L1ProcessInitiatedBridgeEvents(log log.Logger, db *database.DB, metrics L1Metricer, l1Contracts config.L1Contracts, fromHeight, toHeight *big.Int) error {
23
	// (1) OptimismPortal
24
	optimismPortalTxDeposits, err := contracts.OptimismPortalTransactionDepositEvents(l1Contracts.OptimismPortalProxy, db, fromHeight, toHeight)
25 26 27
	if err != nil {
		return err
	}
Hamdi Allam's avatar
Hamdi Allam committed
28 29 30
	if len(optimismPortalTxDeposits) > 0 {
		log.Info("detected transaction deposits", "size", len(optimismPortalTxDeposits))
	}
31

32
	mintedGWEI := bigint.Zero
33
	portalDeposits := make(map[logKey]*contracts.OptimismPortalTransactionDepositEvent, len(optimismPortalTxDeposits))
Hamdi Allam's avatar
Hamdi Allam committed
34
	transactionDeposits := make([]database.L1TransactionDeposit, len(optimismPortalTxDeposits))
35 36 37
	for i := range optimismPortalTxDeposits {
		depositTx := optimismPortalTxDeposits[i]
		portalDeposits[logKey{depositTx.Event.BlockHash, depositTx.Event.LogIndex}] = &depositTx
38
		mintedGWEI = new(big.Int).Add(mintedGWEI, depositTx.Tx.Amount)
39

Hamdi Allam's avatar
Hamdi Allam committed
40
		transactionDeposits[i] = database.L1TransactionDeposit{
41 42 43 44 45 46 47
			SourceHash:           depositTx.DepositTx.SourceHash,
			L2TransactionHash:    types.NewTx(depositTx.DepositTx).Hash(),
			InitiatedL1EventGUID: depositTx.Event.GUID,
			GasLimit:             depositTx.GasLimit,
			Tx:                   depositTx.Tx,
		}
	}
48

49 50 51 52
	if len(transactionDeposits) > 0 {
		if err := db.BridgeTransactions.StoreL1TransactionDeposits(transactionDeposits); err != nil {
			return err
		}
53 54

		// Convert to from wei to eth
55 56
		mintedETH, _ := bigint.WeiToETH(mintedGWEI).Float64()
		metrics.RecordL1TransactionDeposits(len(transactionDeposits), mintedETH)
57 58 59
	}

	// (2) L1CrossDomainMessenger
60
	crossDomainSentMessages, err := contracts.CrossDomainMessengerSentMessageEvents("l1", l1Contracts.L1CrossDomainMessengerProxy, db, fromHeight, toHeight)
61 62 63
	if err != nil {
		return err
	}
Hamdi Allam's avatar
Hamdi Allam committed
64 65
	if len(crossDomainSentMessages) > 0 {
		log.Info("detected sent messages", "size", len(crossDomainSentMessages))
66 67 68
	}

	sentMessages := make(map[logKey]*contracts.CrossDomainMessengerSentMessageEvent, len(crossDomainSentMessages))
Hamdi Allam's avatar
Hamdi Allam committed
69
	bridgeMessages := make([]database.L1BridgeMessage, len(crossDomainSentMessages))
70 71 72 73 74 75 76
	for i := range crossDomainSentMessages {
		sentMessage := crossDomainSentMessages[i]
		sentMessages[logKey{sentMessage.Event.BlockHash, sentMessage.Event.LogIndex}] = &sentMessage

		// extract the deposit hash from the previous TransactionDepositedEvent
		portalDeposit, ok := portalDeposits[logKey{sentMessage.Event.BlockHash, sentMessage.Event.LogIndex - 1}]
		if !ok {
Hamdi Allam's avatar
Hamdi Allam committed
77 78
			log.Error("expected TransactionDeposit preceding SentMessage event", "tx_hash", sentMessage.Event.TransactionHash.String())
			return fmt.Errorf("expected TransactionDeposit preceding SentMessage event. tx_hash = %s", sentMessage.Event.TransactionHash.String())
79 80 81
		} else if portalDeposit.Event.TransactionHash != sentMessage.Event.TransactionHash {
			log.Error("correlated events tx hash mismatch", "deposit_tx_hash", portalDeposit.Event.TransactionHash.String(), "message_tx_hash", sentMessage.Event.TransactionHash.String())
			return fmt.Errorf("correlated events tx hash mismatch")
82 83
		}

Hamdi Allam's avatar
Hamdi Allam committed
84
		bridgeMessages[i] = database.L1BridgeMessage{TransactionSourceHash: portalDeposit.DepositTx.SourceHash, BridgeMessage: sentMessage.BridgeMessage}
85
	}
Hamdi Allam's avatar
Hamdi Allam committed
86 87
	if len(bridgeMessages) > 0 {
		if err := db.BridgeMessages.StoreL1BridgeMessages(bridgeMessages); err != nil {
88 89
			return err
		}
Hamdi Allam's avatar
Hamdi Allam committed
90
		metrics.RecordL1CrossDomainSentMessages(len(bridgeMessages))
91 92 93
	}

	// (3) L1StandardBridge
94
	initiatedBridges, err := contracts.StandardBridgeInitiatedEvents("l1", l1Contracts.L1StandardBridgeProxy, db, fromHeight, toHeight)
95 96 97
	if err != nil {
		return err
	}
Hamdi Allam's avatar
Hamdi Allam committed
98 99
	if len(initiatedBridges) > 0 {
		log.Info("detected bridge deposits", "size", len(initiatedBridges))
100 101
	}

Hamdi Allam's avatar
Hamdi Allam committed
102 103
	bridgedTokens := make(map[common.Address]int)
	bridgeDeposits := make([]database.L1BridgeDeposit, len(initiatedBridges))
104 105 106 107 108 109
	for i := range initiatedBridges {
		initiatedBridge := initiatedBridges[i]

		// extract the cross domain message hash & deposit source hash from the following events
		portalDeposit, ok := portalDeposits[logKey{initiatedBridge.Event.BlockHash, initiatedBridge.Event.LogIndex + 1}]
		if !ok {
Hamdi Allam's avatar
Hamdi Allam committed
110 111
			log.Error("expected TransactionDeposit following BridgeInitiated event", "tx_hash", initiatedBridge.Event.TransactionHash.String())
			return fmt.Errorf("expected TransactionDeposit following BridgeInitiated event. tx_hash = %s", initiatedBridge.Event.TransactionHash.String())
112 113 114
		} else if portalDeposit.Event.TransactionHash != initiatedBridge.Event.TransactionHash {
			log.Error("correlated events tx hash mismatch", "deposit_tx_hash", portalDeposit.Event.TransactionHash.String(), "bridge_tx_hash", initiatedBridge.Event.TransactionHash.String())
			return fmt.Errorf("correlated events tx hash mismatch")
115
		}
116

117 118
		sentMessage, ok := sentMessages[logKey{initiatedBridge.Event.BlockHash, initiatedBridge.Event.LogIndex + 2}]
		if !ok {
119 120 121 122 123
			log.Error("expected SentMessage following BridgeInitiated event", "tx_hash", initiatedBridge.Event.TransactionHash.String())
			return fmt.Errorf("expected SentMessage following BridgeInitiated event. tx_hash = %s", initiatedBridge.Event.TransactionHash.String())
		} else if sentMessage.Event.TransactionHash != initiatedBridge.Event.TransactionHash {
			log.Error("correlated events tx hash mismatch", "message_tx_hash", sentMessage.Event.TransactionHash.String(), "bridge_tx_hash", initiatedBridge.Event.TransactionHash.String())
			return fmt.Errorf("correlated events tx hash mismatch")
124 125
		}

Hamdi Allam's avatar
Hamdi Allam committed
126
		bridgedTokens[initiatedBridge.BridgeTransfer.TokenPair.LocalTokenAddress]++
127

128
		initiatedBridge.BridgeTransfer.CrossDomainMessageHash = &sentMessage.BridgeMessage.MessageHash
Hamdi Allam's avatar
Hamdi Allam committed
129
		bridgeDeposits[i] = database.L1BridgeDeposit{
130 131 132 133
			TransactionSourceHash: portalDeposit.DepositTx.SourceHash,
			BridgeTransfer:        initiatedBridge.BridgeTransfer,
		}
	}
Hamdi Allam's avatar
Hamdi Allam committed
134 135
	if len(bridgeDeposits) > 0 {
		if err := db.BridgeTransfers.StoreL1BridgeDeposits(bridgeDeposits); err != nil {
136 137
			return err
		}
Hamdi Allam's avatar
Hamdi Allam committed
138 139 140
		for tokenAddr, size := range bridgedTokens {
			metrics.RecordL1InitiatedBridgeTransfers(tokenAddr, size)
		}
141 142 143 144 145 146 147 148 149
	}

	return nil
}

// L1ProcessFinalizedBridgeEvent will query the database for all the finalization markers for all initiated
// bridge events. This covers every part of the multi-layered stack:
//  1. OptimismPortal (Bedrock prove & finalize steps)
//  2. L1CrossDomainMessenger (relayMessage marker)
Hamdi Allam's avatar
Hamdi Allam committed
150
//  3. L1StandardBridge (no-op, since this is simply a wrapper over the L1CrossDomainMessenger)
Hamdi Allam's avatar
Hamdi Allam committed
151
func L1ProcessFinalizedBridgeEvents(log log.Logger, db *database.DB, metrics L1Metricer, l1Contracts config.L1Contracts, fromHeight, toHeight *big.Int) error {
152
	// (1) OptimismPortal (proven withdrawals)
153
	provenWithdrawals, err := contracts.OptimismPortalWithdrawalProvenEvents(l1Contracts.OptimismPortalProxy, db, fromHeight, toHeight)
154 155 156
	if err != nil {
		return err
	}
Hamdi Allam's avatar
Hamdi Allam committed
157 158 159
	if len(provenWithdrawals) > 0 {
		log.Info("detected proven withdrawals", "size", len(provenWithdrawals))
	}
160 161 162 163 164 165 166

	for i := range provenWithdrawals {
		proven := provenWithdrawals[i]
		withdrawal, err := db.BridgeTransactions.L2TransactionWithdrawal(proven.WithdrawalHash)
		if err != nil {
			return err
		} else if withdrawal == nil {
Hamdi Allam's avatar
Hamdi Allam committed
167 168
			log.Error("missing indexed withdrawal on proven event!", "tx_hash", proven.Event.TransactionHash.String())
			return fmt.Errorf("missing indexed withdrawal! tx_hash = %s", proven.Event.TransactionHash.String())
169 170 171
		}

		if err := db.BridgeTransactions.MarkL2TransactionWithdrawalProvenEvent(proven.WithdrawalHash, provenWithdrawals[i].Event.GUID); err != nil {
Hamdi Allam's avatar
Hamdi Allam committed
172
			log.Error("failed to mark withdrawal as proven", "err", err, "tx_hash", proven.Event.TransactionHash.String())
173 174 175
			return err
		}
	}
Hamdi Allam's avatar
Hamdi Allam committed
176 177 178
	if len(provenWithdrawals) > 0 {
		metrics.RecordL1ProvenWithdrawals(len(provenWithdrawals))
	}
179 180

	// (2) OptimismPortal (finalized withdrawals)
181
	finalizedWithdrawals, err := contracts.OptimismPortalWithdrawalFinalizedEvents(l1Contracts.OptimismPortalProxy, db, fromHeight, toHeight)
182 183 184
	if err != nil {
		return err
	}
Hamdi Allam's avatar
Hamdi Allam committed
185 186 187
	if len(finalizedWithdrawals) > 0 {
		log.Info("detected finalized withdrawals", "size", len(finalizedWithdrawals))
	}
188 189

	for i := range finalizedWithdrawals {
190 191
		finalizedWithdrawal := finalizedWithdrawals[i]
		withdrawal, err := db.BridgeTransactions.L2TransactionWithdrawal(finalizedWithdrawal.WithdrawalHash)
192 193 194
		if err != nil {
			return err
		} else if withdrawal == nil {
195 196 197 198 199 200
			log.Error("missing indexed withdrawal on finalization event!", "tx_hash", finalizedWithdrawal.Event.TransactionHash.String())
			return fmt.Errorf("missing indexed withdrawal on finalization! tx_hash: %s", finalizedWithdrawal.Event.TransactionHash.String())
		}

		if err = db.BridgeTransactions.MarkL2TransactionWithdrawalFinalizedEvent(finalizedWithdrawal.WithdrawalHash, finalizedWithdrawal.Event.GUID, finalizedWithdrawal.Success); err != nil {
			log.Error("failed to mark withdrawal as finalized", "err", err, "tx_hash", finalizedWithdrawal.Event.TransactionHash.String())
201 202 203
			return err
		}
	}
Hamdi Allam's avatar
Hamdi Allam committed
204 205 206
	if len(finalizedWithdrawals) > 0 {
		metrics.RecordL1FinalizedWithdrawals(len(finalizedWithdrawals))
	}
207 208

	// (3) L1CrossDomainMessenger
209
	crossDomainRelayedMessages, err := contracts.CrossDomainMessengerRelayedMessageEvents("l1", l1Contracts.L1CrossDomainMessengerProxy, db, fromHeight, toHeight)
210 211 212
	if err != nil {
		return err
	}
Hamdi Allam's avatar
Hamdi Allam committed
213 214 215
	if len(crossDomainRelayedMessages) > 0 {
		log.Info("detected relayed messages", "size", len(crossDomainRelayedMessages))
	}
216 217 218 219 220 221 222

	for i := range crossDomainRelayedMessages {
		relayed := crossDomainRelayedMessages[i]
		message, err := db.BridgeMessages.L2BridgeMessage(relayed.MessageHash)
		if err != nil {
			return err
		} else if message == nil {
Hamdi Allam's avatar
Hamdi Allam committed
223 224
			log.Error("missing indexed L2CrossDomainMessenger message", "tx_hash", relayed.Event.TransactionHash.String())
			return fmt.Errorf("missing indexed L2CrossDomainMessager message. tx_hash %s", relayed.Event.TransactionHash.String())
225 226 227
		}

		if err := db.BridgeMessages.MarkRelayedL2BridgeMessage(relayed.MessageHash, relayed.Event.GUID); err != nil {
Hamdi Allam's avatar
Hamdi Allam committed
228
			log.Error("failed to relay cross domain message", "err", err, "tx_hash", relayed.Event.TransactionHash.String())
229 230 231
			return err
		}
	}
Hamdi Allam's avatar
Hamdi Allam committed
232 233 234
	if len(crossDomainRelayedMessages) > 0 {
		metrics.RecordL1CrossDomainRelayedMessages(len(crossDomainRelayedMessages))
	}
235 236

	// (4) L1StandardBridge
237 238 239
	// - Nothing actionable on the database. Since the StandardBridge is layered ontop of the
	// CrossDomainMessenger, there's no need for any sanity or invariant checks as the previous step
	// ensures a relayed message (finalized bridge) can be linked with a sent message (initiated bridge).
240
	finalizedBridges, err := contracts.StandardBridgeFinalizedEvents("l1", l1Contracts.L1StandardBridgeProxy, db, fromHeight, toHeight)
241 242 243 244
	if err != nil {
		return err
	}

Hamdi Allam's avatar
Hamdi Allam committed
245
	finalizedTokens := make(map[common.Address]int)
246 247
	for i := range finalizedBridges {
		finalizedBridge := finalizedBridges[i]
Hamdi Allam's avatar
Hamdi Allam committed
248 249 250
		finalizedTokens[finalizedBridge.BridgeTransfer.TokenPair.LocalTokenAddress]++
	}
	if len(finalizedBridges) > 0 {
251
		log.Info("detected finalized bridge withdrawals", "size", len(finalizedBridges))
Hamdi Allam's avatar
Hamdi Allam committed
252 253 254
		for tokenAddr, size := range finalizedTokens {
			metrics.RecordL1FinalizedBridgeTransfers(tokenAddr, size)
		}
255 256 257 258 259
	}

	// a-ok!
	return nil
}