Merge branch 'develop' into inphi/fpvm-oob

.changeset/bright-mayflies-jog.md

+---
+'@eth-optimism/sdk': patch
+---
+
+Fixed missing indexes for multicall support

cannon/mipsevm/evm.go

@@ -24,7 +24,7 @@ import (
 )
 
 var (
-	StepBytes4                      = crypto.Keccak256([]byte("Step(bytes,bytes)"))[:4]
+	StepBytes4                      = crypto.Keccak256([]byte("step(bytes,bytes)"))[:4]
 	CheatBytes4                     = crypto.Keccak256([]byte("cheat(uint256,bytes32,bytes32,uint256)"))[:4]
 	LoadKeccak256PreimagePartBytes4 = crypto.Keccak256([]byte("loadKeccak256PreimagePart(uint256,bytes)"))[:4]
 )

cannon/mipsevm/evm_test.go

@@ -63,6 +63,8 @@ func TestEVM(t *testing.T) {
 			if strings.HasPrefix(f.Name(), "oracle") {
 				oracle = staticOracle(t, []byte("hello world"))
 			}
+			// Short-circuit early for exit_group.bin
+			exitGroup := f.Name() == "exit_group.bin"
 
 			env, evmState := NewEVMEnv(contracts, addrs)
 			env.Config.Tracer = tracer
@@ -83,6 +85,9 @@ func TestEVM(t *testing.T) {
 				if us.state.PC == endAddr {
 					break
 				}
+				if exitGroup && us.state.Exited {
+					break
+				}
 				insn := state.Memory.GetMemory(state.PC)
 				t.Logf("step: %4d pc: 0x%08x insn: 0x%08x", state.Step, state.PC, insn)
 
@@ -122,11 +127,17 @@ func TestEVM(t *testing.T) {
 				require.Equal(t, hexutil.Bytes(uniPost).String(), hexutil.Bytes(evmPost).String(),
 					"mipsevm produced different state than EVM")
 			}
-			require.Equal(t, uint32(endAddr), state.PC, "must reach end")
-			// inspect test result
-			done, result := state.Memory.GetMemory(baseAddrEnd+4), state.Memory.GetMemory(baseAddrEnd+8)
-			require.Equal(t, done, uint32(1), "must be done")
-			require.Equal(t, result, uint32(1), "must have success result")
+			if exitGroup {
+				require.NotEqual(t, uint32(endAddr), us.state.PC, "must not reach end")
+				require.True(t, us.state.Exited, "must set exited state")
+				require.Equal(t, uint8(1), us.state.ExitCode, "must exit with 1")
+			} else {
+				require.Equal(t, uint32(endAddr), state.PC, "must reach end")
+				// inspect test result
+				done, result := state.Memory.GetMemory(baseAddrEnd+4), state.Memory.GetMemory(baseAddrEnd+8)
+				require.Equal(t, done, uint32(1), "must be done")
+				require.Equal(t, result, uint32(1), "must have success result")
+			}
 		})
 	}
 }

cannon/mipsevm/open_mips_tests/test/brk.asm

+.section .test, "x"
+    .balign 4
+    .set    noreorder
+    .global test
+    .ent    test
+
+test:
+  li $v0, 4045
+  syscall
+  lui $t0, 0x4000
+  subu $v0, $v0, $t0
+  sltiu $v0, $v0, 1
+
+# save results
+  lui     $s0, 0xbfff         # Load the base address 0xbffffff0
+  ori     $s0, 0xfff0
+  ori     $s1, $0, 1          # Prepare the 'done' status
+
+  sw      $v0, 8($s0)         # Set the test result
+  sw      $s1, 4($s0)         # Set 'done'
+
+$done:
+  jr $ra
+  nop
+
+  .end test

cannon/mipsevm/open_mips_tests/test/clone.asm

+.section .test, "x"
+    .balign 4
+    .set    noreorder
+    .global test
+    .ent    test
+
+test:
+  li $v0, 4120
+  syscall
+  li $t0, 0x1
+  subu $v0, $v0, $t0
+  sltiu $v0, $v0, 1
+
+# save results
+  lui     $s0, 0xbfff         # Load the base address 0xbffffff0
+  ori     $s0, 0xfff0
+  ori     $s1, $0, 1          # Prepare the 'done' status
+
+  sw      $v0, 8($s0)         # Set the test result
+  sw      $s1, 4($s0)         # Set 'done'
+
+$done:
+  jr $ra
+  nop
+
+  .end test

cannon/mipsevm/open_mips_tests/test/exit_group.asm

+.section .test, "x"
+    .balign 4
+    .set    noreorder
+    .global test
+    .ent    test
+
+test:
+  li $a0, 1
+  li $v0, 4246
+  syscall
+
+  # Unreachable ....
+  # set test result to fail.
+  # Test runner should short-circuit before reaching this point.
+  li $v0, 0
+
+  # save results
+  lui     $s0, 0xbfff         # Load the base address 0xbffffff0
+  ori     $s0, 0xfff0
+  ori     $s1, $0, 1          # Prepare the 'done' status
+
+  sw      $v0, 8($s0)         # Set the test result
+  sw      $s1, 4($s0)         # Set 'done'
+
+$done:
+  jr $ra
+  nop
+
+  .end test

cannon/mipsevm/open_mips_tests/test/fcntl.asm

+.section .test, "x"
+    .balign 4
+    .set    noreorder
+    .global test
+    .ent    test
+
+test:
+  # fnctl(0, 3)
+  li $v0, 4055
+  li $a0, 0x0
+  li $a1, 0x3
+  syscall
+  sltiu $v0, $v0, 1
+
+# save results
+  lui     $s0, 0xbfff         # Load the base address 0xbffffff0
+  ori     $s0, 0xfff0
+  ori     $s1, $0, 1          # Prepare the 'done' status
+
+  sw      $v0, 8($s0)         # Set the test result
+  sw      $s1, 4($s0)         # Set 'done'
+
+$done:
+  jr $ra
+  nop
+
+  .end test

cannon/mipsevm/open_mips_tests/test/mmap.asm

+.section .test, "x"
+    .balign 4
+    .set    noreorder
+    .global test
+    .ent    test
+
+test:
+  li $v0, 4090
+  lui $a0, 0x3000
+  li $a1, 4096
+  syscall
+  lui $t0, 0x3000
+  subu $v0, $v0, $t0
+  sltiu $v0, $v0, 1
+
+ # save results
+  lui     $s0, 0xbfff         # Load the base address 0xbffffff0
+  ori     $s0, 0xfff0
+  ori     $s1, $0, 1          # Prepare the 'done' status
+
+  sw      $v0, 8($s0)         # Set the test result
+  sw      $s1, 4($s0)         # Set 'done'
+
+$done:
+  jr $ra
+  nop
+
+  .end test

cannon/mipsevm/state_test.go

@@ -35,6 +35,9 @@ func TestState(t *testing.T) {
 			if strings.HasPrefix(f.Name(), "oracle") {
 				oracle = staticOracle(t, []byte("hello world"))
 			}
+			// Short-circuit early for exit_group.bin
+			exitGroup := f.Name() == "exit_group.bin"
+
 			// TODO: currently tests are compiled as flat binary objects
 			// We can use more standard tooling to compile them to ELF files and get remove maketests.py
 			fn := path.Join("open_mips_tests/test/bin", f.Name())
@@ -57,14 +60,24 @@ func TestState(t *testing.T) {
 				if us.state.PC == endAddr {
 					break
 				}
+				if exitGroup && us.state.Exited {
+					break
+				}
 				_, err := us.Step(false)
 				require.NoError(t, err)
 			}
-			require.Equal(t, uint32(endAddr), us.state.PC, "must reach end")
-			// inspect test result
-			done, result := state.Memory.GetMemory(baseAddrEnd+4), state.Memory.GetMemory(baseAddrEnd+8)
-			require.Equal(t, done, uint32(1), "must be done")
-			require.Equal(t, result, uint32(1), "must have success result")
+
+			if exitGroup {
+				require.NotEqual(t, uint32(endAddr), us.state.PC, "must not reach end")
+				require.True(t, us.state.Exited, "must set exited state")
+				require.Equal(t, uint8(1), us.state.ExitCode, "must exit with 1")
+			} else {
+				require.Equal(t, uint32(endAddr), us.state.PC, "must reach end")
+				done, result := state.Memory.GetMemory(baseAddrEnd+4), state.Memory.GetMemory(baseAddrEnd+8)
+				// inspect test result
+				require.Equal(t, done, uint32(1), "must be done")
+				require.Equal(t, result, uint32(1), "must have success result")
+			}
 		})
 	}
 }

docs/op-stack/src/docs/build/getting-started.md

@@ -30,7 +30,7 @@ You’ll need the following software installed to follow this tutorial:
 - [Git](https://git-scm.com/)
 - [Go](https://go.dev/)
 - [Node](https://nodejs.org/en/)
-- [Yarn](https://classic.yarnpkg.com/lang/en/docs/install/)
+- [Pnpm](https://classic.yarnpkg.com/lang/en/docs/install/)
 - [Foundry](https://github.com/foundry-rs/foundry#installation)
 - [Make](https://linux.die.net/man/1/make)
 - [jq](https://github.com/jqlang/jq)
@@ -44,7 +44,7 @@ This tutorial was checked on:
 | git, curl, jq, and make | OS default | `sudo apt install -y git curl make jq` |
 | Go       | 1.20       | `sudo apt update` <br> `wget https://go.dev/dl/go1.20.linux-amd64.tar.gz` <br> `tar xvzf go1.20.linux-amd64.tar.gz` <br> `sudo cp go/bin/go /usr/bin/go` <br> `sudo mv go /usr/lib` <br> `echo export GOROOT=/usr/lib/go >> ~/.bashrc`
 | Node     | 16.19.0    | `curl -fsSL https://deb.nodesource.com/setup_16.x | sudo -E bash -` <br> `sudo apt-get install -y nodejs npm`
-| yarn     | 1.22.19    | `sudo npm install -g yarn`
+| pnpm     | 8.5.6      | `sudo npm install -g pnpm`
 | Foundry  | 0.2.0      | `yarn install:foundry`
 
 ## Build the Source Code
@@ -69,14 +69,14 @@ We’re going to be spinning up an EVM Rollup from the OP Stack source code.  Yo
 1. Install required modules. This is a slow process, while it is running you can already start building `op-geth`, as shown below.
 
     ```bash
-    yarn install
+    pnpm install
     ```
 
 1. Build the various packages inside of the Optimism Monorepo.
 
     ```bash
     make op-node op-batcher op-proposer
-    yarn build
+    pnpm build
     ```
 
 ### Build op-geth
@@ -278,7 +278,7 @@ We’ve set up the L1 side of things, but now we need to set up the L2 side of t
 
     You should then see the `genesis.json` and `rollup.json` files inside the `op-node` package.
 
-1. Next, generate the `jwt.txt` file with the following command:
+ 1. Next, generate the `jwt.txt` file with the following command:
 
     ```bash
     openssl rand -hex 32 > jwt.txt
@@ -307,24 +307,6 @@ We’re almost ready to run our chain! Now we just need to run a few commands to
     mkdir datadir
     ```
 
-1. Put a password file into the data directory folder:
-
-    ```bash
-    echo "pwd" > datadir/password
-    ```
-
-1. Put the `Sequencer` private key into the data directory folder (don’t include a “0x” prefix):
-
-    ```bash
-    echo "<SEQUENCER KEY HERE>" > datadir/block-signer-key
-    ```
-
-1. Import the key into `op-geth`:
-
-    ```bash
-    ./build/bin/geth account import --datadir=datadir --password=datadir/password datadir/block-signer-key
-    ```
-
 1. Next we need to initialize `op-geth` with the genesis file we generated and copied earlier:
 
     ```bash
@@ -344,7 +326,6 @@ Set these environment variables for the configuration
 
 | Variable       | Value |
 | -------------- | -
-| `SEQ_ADDR`     | Address of the `Sequencer` account
 | `SEQ_KEY`      | Private key of the `Sequencer` account
 | `BATCHER_KEY`  | Private key of the `Batcher` accounts, which should have at least 1 ETH
 | `PROPOSER_KEY` | Private key of the `Proposer` account
@@ -360,32 +341,27 @@ Run `op-geth` with the following commands.
 cd ~/op-geth
 
 ./build/bin/geth \
-	--datadir ./datadir \
-	--http \
-	--http.corsdomain="*" \
-	--http.vhosts="*" \
-	--http.addr=0.0.0.0 \
-	--http.api=web3,debug,eth,txpool,net,engine \
-	--ws \
-	--ws.addr=0.0.0.0 \
-	--ws.port=8546 \
-	--ws.origins="*" \
-	--ws.api=debug,eth,txpool,net,engine \
-	--syncmode=full \
-	--gcmode=archive \
-	--nodiscover \
-	--maxpeers=0 \
-	--networkid=42069 \
-	--authrpc.vhosts="*" \
-	--authrpc.addr=0.0.0.0 \
-	--authrpc.port=8551 \
-	--authrpc.jwtsecret=./jwt.txt \
-	--rollup.disabletxpoolgossip=true \
-	--password=./datadir/password \
-	--allow-insecure-unlock \
-	--mine \
-	--miner.etherbase=$SEQ_ADDR \
-	--unlock=$SEQ_ADDR
+        --datadir ./datadir \
+        --http \
+        --http.corsdomain="*" \
+        --http.vhosts="*" \
+        --http.addr=0.0.0.0 \
+        --http.api=web3,debug,eth,txpool,net,engine \
+        --ws \
+        --ws.addr=0.0.0.0 \
+        --ws.port=8546 \
+        --ws.origins="*" \
+        --ws.api=debug,eth,txpool,net,engine \
+        --syncmode=full \
+        --gcmode=archive \
+        --nodiscover \
+        --maxpeers=0 \
+        --networkid=42069 \
+        --authrpc.vhosts="*" \
+        --authrpc.addr=0.0.0.0 \
+        --authrpc.port=8551 \
+        --authrpc.jwtsecret=./jwt.txt \
+        --rollup.disabletxpoolgossip=true
 ```
 
 And `op-geth` should be running! You should see some output, but you won’t see any blocks being created yet because `op-geth` is driven by the `op-node`. We’ll need to get that running next.
@@ -443,7 +419,7 @@ cd ~/optimism/op-node
 
 ./bin/op-node \
 	--l2=http://localhost:8551 \
-	--l2.jwt-secret=./jwt.txt \
+	--l2.jwt-secret=./jwt.txt \    
 	--sequencer.enabled \
 	--sequencer.l1-confs=3 \
 	--verifier.l1-confs=3 \

indexer/api/api_test.go

 package api
 
 import (
+	"math/big"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -25,7 +26,7 @@ func (mbv *MockBridgeView) DepositsByAddress(address common.Address) ([]*databas
 		{
 			Deposit: database.Deposit{
 				GUID:                 uuid.MustParse(guid1),
-				InitiatedL1EventGUID: guid2,
+				InitiatedL1EventGUID: uuid.MustParse(guid2),
 				Tx:                   database.Transaction{},
 				TokenPair:            database.TokenPair{},
 			},
@@ -34,13 +35,28 @@ func (mbv *MockBridgeView) DepositsByAddress(address common.Address) ([]*databas
 	}, nil
 }
 
+// DepositsByAddress mocks returning deposits by an address
+func (mbv *MockBridgeView) DepositByMessageNonce(nonce *big.Int) (*database.Deposit, error) {
+	return &database.Deposit{
+		GUID:                 uuid.MustParse(guid1),
+		InitiatedL1EventGUID: uuid.MustParse(guid2),
+		Tx:                   database.Transaction{},
+		TokenPair:            database.TokenPair{},
+	}, nil
+}
+
+// LatestDepositMessageNonce mocks returning the latest cross domain message nonce for a deposit
+func (mbv *MockBridgeView) LatestDepositMessageNonce() (*big.Int, error) {
+	return big.NewInt(0), nil
+}
+
 // WithdrawalsByAddress mocks returning withdrawals by an address
 func (mbv *MockBridgeView) WithdrawalsByAddress(address common.Address) ([]*database.WithdrawalWithTransactionHashes, error) {
 	return []*database.WithdrawalWithTransactionHashes{
 		{
 			Withdrawal: database.Withdrawal{
 				GUID:                 uuid.MustParse(guid2),
-				InitiatedL2EventGUID: guid1,
+				InitiatedL2EventGUID: uuid.MustParse(guid1),
 				WithdrawalHash:       common.HexToHash("0x456"),
 				Tx:                   database.Transaction{},
 				TokenPair:            database.TokenPair{},
@@ -50,6 +66,33 @@ func (mbv *MockBridgeView) WithdrawalsByAddress(address common.Address) ([]*data
 	}, nil
 }
 
+// WithdrawalsByMessageNonce mocks returning withdrawals by a withdrawal hash
+func (mbv *MockBridgeView) WithdrawalByMessageNonce(nonce *big.Int) (*database.Withdrawal, error) {
+	return &database.Withdrawal{
+		GUID:                 uuid.MustParse(guid2),
+		InitiatedL2EventGUID: uuid.MustParse(guid1),
+		WithdrawalHash:       common.HexToHash("0x456"),
+		Tx:                   database.Transaction{},
+		TokenPair:            database.TokenPair{},
+	}, nil
+}
+
+// WithdrawalsByHash mocks returning withdrawals by a withdrawal hash
+func (mbv *MockBridgeView) WithdrawalByHash(address common.Hash) (*database.Withdrawal, error) {
+	return &database.Withdrawal{
+		GUID:                 uuid.MustParse(guid2),
+		InitiatedL2EventGUID: uuid.MustParse(guid1),
+		WithdrawalHash:       common.HexToHash("0x456"),
+		Tx:                   database.Transaction{},
+		TokenPair:            database.TokenPair{},
+	}, nil
+}
+
+// LatestWithdrawalMessageNonce mocks returning the latest cross domain message nonce for a withdrawal
+func (mbv *MockBridgeView) LatestWithdrawalMessageNonce() (*big.Int, error) {
+	return big.NewInt(0), nil
+}
+
 func TestHealthz(t *testing.T) {
 	api := NewApi(&MockBridgeView{})
 	request, err := http.NewRequest("GET", "/healthz", nil)

indexer/database/blocks.go

@@ -5,6 +5,8 @@ import (
 	"errors"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+
 	"github.com/google/uuid"
 
 	"gorm.io/gorm"
@@ -21,6 +23,15 @@ type BlockHeader struct {
 	Timestamp  uint64
 }
 
+func BlockHeaderFromGethHeader(header *types.Header) BlockHeader {
+	return BlockHeader{
+		Hash:       header.Hash(),
+		ParentHash: header.ParentHash,
+		Number:     U256{Int: header.Number},
+		Timestamp:  header.Time,
+	}
+}
+
 type L1BlockHeader struct {
 	BlockHeader
 }
@@ -41,8 +52,9 @@ type LegacyStateBatch struct {
 }
 
 type OutputProposal struct {
-	OutputRoot          common.Hash `gorm:"primaryKey;serializer:json"`
-	L2BlockNumber       U256
+	OutputRoot    common.Hash `gorm:"primaryKey;serializer:json"`
+	L2BlockNumber U256
+
 	L1ContractEventGUID uuid.UUID
 }
 

indexer/database/bridge.go

@@ -2,6 +2,8 @@ package database
 
 import (
 	"errors"
+	"fmt"
+	"math/big"
 
 	"gorm.io/gorm"
 
@@ -30,7 +32,17 @@ type TokenPair struct {
 
 type Deposit struct {
 	GUID                 uuid.UUID `gorm:"primaryKey"`
-	InitiatedL1EventGUID string
+	InitiatedL1EventGUID uuid.UUID
+
+	// Since we're only currently indexing a single StandardBridge,
+	// the message nonce serves as a unique identifier for this
+	// deposit. Once this generalizes to more than 1 deployed
+	// bridge, we need to include the `CrossDomainMessenger` address
+	// such that the (messenger_addr, nonce) is the unique identifier
+	// for a bridge msg
+	SentMessageNonce U256
+
+	FinalizedL2EventGUID *uuid.UUID
 
 	Tx        Transaction `gorm:"embedded"`
 	TokenPair TokenPair   `gorm:"embedded"`
@@ -43,11 +55,19 @@ type DepositWithTransactionHash struct {
 
 type Withdrawal struct {
 	GUID                 uuid.UUID `gorm:"primaryKey"`
-	InitiatedL2EventGUID string
+	InitiatedL2EventGUID uuid.UUID
+
+	// Since we're only currently indexing a single StandardBridge,
+	// the message nonce serves as a unique identifier for this
+	// withdrawal. Once this generalizes to more than 1 deployed
+	// bridge, we need to include the `CrossDomainMessenger` address
+	// such that the (messenger_addr, nonce) is the unique identifier
+	// for a bridge msg
+	SentMessageNonce U256
 
 	WithdrawalHash       common.Hash `gorm:"serializer:json"`
-	ProvenL1EventGUID    *string
-	FinalizedL1EventGUID *string
+	ProvenL1EventGUID    *uuid.UUID
+	FinalizedL1EventGUID *uuid.UUID
 
 	Tx        Transaction `gorm:"embedded"`
 	TokenPair TokenPair   `gorm:"embedded"`
@@ -63,16 +83,24 @@ type WithdrawalWithTransactionHashes struct {
 
 type BridgeView interface {
 	DepositsByAddress(address common.Address) ([]*DepositWithTransactionHash, error)
+	DepositByMessageNonce(*big.Int) (*Deposit, error)
+	LatestDepositMessageNonce() (*big.Int, error)
+
 	WithdrawalsByAddress(address common.Address) ([]*WithdrawalWithTransactionHashes, error)
+	WithdrawalByMessageNonce(*big.Int) (*Withdrawal, error)
+	WithdrawalByHash(common.Hash) (*Withdrawal, error)
+	LatestWithdrawalMessageNonce() (*big.Int, error)
 }
 
 type BridgeDB interface {
 	BridgeView
 
 	StoreDeposits([]*Deposit) error
+	MarkFinalizedDepositEvent(uuid.UUID, uuid.UUID) error
+
 	StoreWithdrawals([]*Withdrawal) error
-	MarkProvenWithdrawalEvent(string, string) error
-	MarkFinalizedWithdrawalEvent(string, string) error
+	MarkProvenWithdrawalEvent(uuid.UUID, uuid.UUID) error
+	MarkFinalizedWithdrawalEvent(uuid.UUID, uuid.UUID) error
 }
 
 /**
@@ -114,6 +142,46 @@ func (db *bridgeDB) DepositsByAddress(address common.Address) ([]*DepositWithTra
 	return deposits, nil
 }
 
+func (db *bridgeDB) DepositByMessageNonce(nonce *big.Int) (*Deposit, error) {
+	var deposit Deposit
+	result := db.gorm.First(&deposit, "sent_message_nonce = ?", U256{Int: nonce})
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+
+		return nil, result.Error
+	}
+
+	return &deposit, nil
+}
+
+func (db *bridgeDB) LatestDepositMessageNonce() (*big.Int, error) {
+	var deposit Deposit
+	result := db.gorm.Order("sent_message_nonce DESC").Take(&deposit)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+
+		return nil, result.Error
+	}
+
+	return deposit.SentMessageNonce.Int, nil
+}
+
+func (db *bridgeDB) MarkFinalizedDepositEvent(guid, finalizationEventGUID uuid.UUID) error {
+	var deposit Deposit
+	result := db.gorm.First(&deposit, "guid = ?", guid)
+	if result.Error != nil {
+		return result.Error
+	}
+
+	deposit.FinalizedL2EventGUID = &finalizationEventGUID
+	result = db.gorm.Save(&deposit)
+	return result.Error
+}
+
 // Withdrawals
 
 func (db *bridgeDB) StoreWithdrawals(withdrawals []*Withdrawal) error {
@@ -121,7 +189,7 @@ func (db *bridgeDB) StoreWithdrawals(withdrawals []*Withdrawal) error {
 	return result.Error
 }
 
-func (db *bridgeDB) MarkProvenWithdrawalEvent(guid, provenL1EventGuid string) error {
+func (db *bridgeDB) MarkProvenWithdrawalEvent(guid, provenL1EventGuid uuid.UUID) error {
 	var withdrawal Withdrawal
 	result := db.gorm.First(&withdrawal, "guid = ?", guid)
 	if result.Error != nil {
@@ -133,13 +201,17 @@ func (db *bridgeDB) MarkProvenWithdrawalEvent(guid, provenL1EventGuid string) er
 	return result.Error
 }
 
-func (db *bridgeDB) MarkFinalizedWithdrawalEvent(guid, finalizedL1EventGuid string) error {
+func (db *bridgeDB) MarkFinalizedWithdrawalEvent(guid, finalizedL1EventGuid uuid.UUID) error {
 	var withdrawal Withdrawal
 	result := db.gorm.First(&withdrawal, "guid = ?", guid)
 	if result.Error != nil {
 		return result.Error
 	}
 
+	if withdrawal.ProvenL1EventGUID == nil {
+		return fmt.Errorf("withdrawal %s marked finalized prior to being proven", guid)
+	}
+
 	withdrawal.FinalizedL1EventGUID = &finalizedL1EventGuid
 	result = db.gorm.Save(&withdrawal)
 	return result.Error
@@ -167,3 +239,45 @@ func (db *bridgeDB) WithdrawalsByAddress(address common.Address) ([]*WithdrawalW
 
 	return withdrawals, nil
 }
+
+func (db *bridgeDB) WithdrawalByMessageNonce(nonce *big.Int) (*Withdrawal, error) {
+	var withdrawal Withdrawal
+	result := db.gorm.First(&withdrawal, "sent_message_nonce = ?", U256{Int: nonce})
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+
+		return nil, result.Error
+	}
+
+	return &withdrawal, nil
+}
+
+func (db *bridgeDB) WithdrawalByHash(hash common.Hash) (*Withdrawal, error) {
+	var withdrawal Withdrawal
+	result := db.gorm.First(&withdrawal, "withdrawal_hash = ?", hash.String())
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+
+		return nil, result.Error
+	}
+
+	return &withdrawal, nil
+}
+
+func (db *bridgeDB) LatestWithdrawalMessageNonce() (*big.Int, error) {
+	var withdrawal Withdrawal
+	result := db.gorm.Order("sent_message_nonce DESC").Take(&withdrawal)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+
+		return nil, result.Error
+	}
+
+	return withdrawal.SentMessageNonce.Int, nil
+}

indexer/database/contract_events.go

@@ -4,6 +4,7 @@ import (
 	"gorm.io/gorm"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 
 	"github.com/google/uuid"
 )
@@ -22,6 +23,20 @@ type ContractEvent struct {
 	Timestamp      uint64
 }
 
+func ContractEventFromGethLog(log *types.Log, timestamp uint64) ContractEvent {
+	return ContractEvent{
+		GUID: uuid.New(),
+
+		BlockHash:       log.BlockHash,
+		TransactionHash: log.TxHash,
+
+		EventSignature: log.Topics[0],
+		LogIndex:       uint64(log.Index),
+
+		Timestamp: timestamp,
+	}
+}
+
 type L1ContractEvent struct {
 	ContractEvent `gorm:"embedded"`
 }

indexer/migrations/20230523_create_schema.sql

@@ -10,14 +10,15 @@ CREATE TABLE IF NOT EXISTS l1_block_headers (
 	hash        VARCHAR NOT NULL PRIMARY KEY,
 	parent_hash VARCHAR NOT NULL,
 	number      UINT256,
-	timestamp   INTEGER NOT NULL
+	timestamp   INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
 CREATE TABLE IF NOT EXISTS l2_block_headers (
-	hash        VARCHAR NOT NULL PRIMARY KEY,
-	parent_hash VARCHAR NOT NULL,
-	number      UINT256,
-	timestamp   INTEGER NOT NULL
+    -- Block header
+	hash                     VARCHAR NOT NULL PRIMARY KEY,
+	parent_hash              VARCHAR NOT NULL,
+	number                   UINT256,
+	timestamp                INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
 /** 
@@ -30,7 +31,7 @@ CREATE TABLE IF NOT EXISTS l1_contract_events (
     transaction_hash VARCHAR NOT NULL,
     event_signature  VARCHAR NOT NULL,
     log_index        INTEGER NOT NULL,
-    timestamp        INTEGER NOT NULL
+    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
 CREATE TABLE IF NOT EXISTS l2_contract_events (
@@ -39,7 +40,7 @@ CREATE TABLE IF NOT EXISTS l2_contract_events (
     transaction_hash VARCHAR NOT NULL,
     event_signature  VARCHAR NOT NULL,
     log_index        INTEGER NOT NULL,
-    timestamp        INTEGER NOT NULL
+    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
 -- Tables that index finalization markers for L2 blocks.
@@ -69,6 +70,10 @@ CREATE TABLE IF NOT EXISTS deposits (
 
     -- Event causing the deposit
     initiated_l1_event_guid VARCHAR NOT NULL REFERENCES l1_contract_events(guid),
+    sent_message_nonce      UINT256 UNIQUE,
+
+    -- Finalization marker for the deposit
+    finalized_l2_event_guid VARCHAR REFERENCES l2_contract_events(guid),
 
     -- Deposit information (do we need indexes on from/to?)
 	from_address     VARCHAR NOT NULL,
@@ -78,7 +83,7 @@ CREATE TABLE IF NOT EXISTS deposits (
 	l2_token_address VARCHAR NOT NULL,
 	amount           UINT256,
 	data             VARCHAR NOT NULL,
-    timestamp        INTEGER NOT NULL
+    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
 CREATE TABLE IF NOT EXISTS withdrawals (
@@ -86,6 +91,7 @@ CREATE TABLE IF NOT EXISTS withdrawals (
 
     -- Event causing this withdrawal
     initiated_l2_event_guid VARCHAR NOT NULL REFERENCES l2_contract_events(guid),
+    sent_message_nonce      UINT256 UNIQUE,
 
     -- Multistep (bedrock) process of a withdrawal
     withdrawal_hash      VARCHAR NOT NULL,
@@ -101,5 +107,5 @@ CREATE TABLE IF NOT EXISTS withdrawals (
 	l2_token_address VARCHAR NOT NULL,
 	amount           UINT256,
 	data             VARCHAR NOT NULL,
-    timestamp        INTEGER NOT NULL
+    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );

indexer/processor/contract_events.go

+package processor
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/google/uuid"
+)
+
+type ProcessedContractEventLogIndexKey struct {
+	header common.Hash
+	index  uint
+}
+
+type ProcessedContractEvents struct {
+	events            []*database.ContractEvent
+	eventsBySignature map[common.Hash][]*database.ContractEvent
+	eventByLogIndex   map[ProcessedContractEventLogIndexKey]*database.ContractEvent
+	eventLog          map[uuid.UUID]*types.Log
+}
+
+func NewProcessedContractEvents() *ProcessedContractEvents {
+	return &ProcessedContractEvents{
+		events:            []*database.ContractEvent{},
+		eventsBySignature: make(map[common.Hash][]*database.ContractEvent),
+		eventByLogIndex:   make(map[ProcessedContractEventLogIndexKey]*database.ContractEvent),
+		eventLog:          make(map[uuid.UUID]*types.Log),
+	}
+}
+
+func (p *ProcessedContractEvents) AddLog(log *types.Log, time uint64) *database.ContractEvent {
+	contractEvent := database.ContractEventFromGethLog(log, time)
+
+	p.events = append(p.events, &contractEvent)
+	p.eventsBySignature[contractEvent.EventSignature] = append(p.eventsBySignature[contractEvent.EventSignature], &contractEvent)
+	p.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index}] = &contractEvent
+	p.eventLog[contractEvent.GUID] = log
+
+	return &contractEvent
+}
+
+func UnpackLog(out interface{}, log *types.Log, name string, contractAbi *abi.ABI) error {
+	eventAbi, ok := contractAbi.Events[name]
+	if !ok {
+		return fmt.Errorf("event %s not present in supplied ABI", name)
+	} else if len(log.Topics) == 0 {
+		return errors.New("anonymous events are not supported")
+	} else if log.Topics[0] != eventAbi.ID {
+		return errors.New("event signature mismatch")
+	}
+
+	err := contractAbi.UnpackIntoInterface(out, name, log.Data)
+	if err != nil {
+		return err
+	}
+
+	// handle topics if present
+	if len(log.Topics) > 1 {
+		var indexedArgs abi.Arguments
+		for _, arg := range eventAbi.Inputs {
+			if arg.Indexed {
+				indexedArgs = append(indexedArgs, arg)
+			}
+		}
+
+		// The first topic (event signature) is omitted
+		err := abi.ParseTopics(out, indexedArgs, log.Topics[1:])
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

indexer/processor/l1_processor.go

@@ -122,21 +122,22 @@ func l1ProcessFn(processLog log.Logger, ethClient node.EthClient, l1Contracts L1
 			headerMap[header.Hash()] = header
 		}
 
-		/** Watch for Contract Events **/
+		/** Watch for all Optimism Contract Events **/
 
 		logFilter := ethereum.FilterQuery{FromBlock: headers[0].Number, ToBlock: headers[numHeaders-1].Number, Addresses: contractAddrs}
-		logs, err := rawEthClient.FilterLogs(context.Background(), logFilter)
+		logs, err := rawEthClient.FilterLogs(context.Background(), logFilter) // []types.Log
 		if err != nil {
 			return err
 		}
 
-		// L2 checkpoitns posted on L1
+		// L2 checkpoints posted on L1
 		outputProposals := []*database.OutputProposal{}
 		legacyStateBatches := []*database.LegacyStateBatch{}
 
-		numLogs := len(logs)
-		l1ContractEvents := make([]*database.L1ContractEvent, numLogs)
 		l1HeadersOfInterest := make(map[common.Hash]bool)
+		l1ContractEvents := make([]*database.L1ContractEvent, len(logs))
+
+		processedContractEvents := NewProcessedContractEvents()
 		for i, log := range logs {
 			header, ok := headerMap[log.BlockHash]
 			if !ok {
@@ -144,19 +145,9 @@ func l1ProcessFn(processLog log.Logger, ethClient node.EthClient, l1Contracts L1
 				return errors.New("parsed log with a block hash not in this batch")
 			}
 
-			contractEvent := &database.L1ContractEvent{
-				ContractEvent: database.ContractEvent{
-					GUID:            uuid.New(),
-					BlockHash:       log.BlockHash,
-					TransactionHash: log.TxHash,
-					EventSignature:  log.Topics[0],
-					LogIndex:        uint64(log.Index),
-					Timestamp:       header.Time,
-				},
-			}
-
-			l1ContractEvents[i] = contractEvent
+			contractEvent := processedContractEvents.AddLog(&logs[i], header.Time)
 			l1HeadersOfInterest[log.BlockHash] = true
+			l1ContractEvents[i] = &database.L1ContractEvent{ContractEvent: *contractEvent}
 
 			// Track Checkpoint Events for L2
 			switch contractEvent.EventSignature {
@@ -194,63 +185,188 @@ func l1ProcessFn(processLog log.Logger, ethClient node.EthClient, l1Contracts L1
 
 		// we iterate on the original array to maintain ordering. probably can find a more efficient
 		// way to iterate over the `l1HeadersOfInterest` map while maintaining ordering
-		l1Headers := []*database.L1BlockHeader{}
+		indexedL1Headers := []*database.L1BlockHeader{}
 		for _, header := range headers {
-			blockHash := header.Hash()
-			if _, hasLogs := l1HeadersOfInterest[blockHash]; !hasLogs {
+			_, hasLogs := l1HeadersOfInterest[header.Hash()]
+			if !hasLogs {
 				continue
 			}
 
-			l1Headers = append(l1Headers, &database.L1BlockHeader{
-				BlockHeader: database.BlockHeader{
-					Hash:       blockHash,
-					ParentHash: header.ParentHash,
-					Number:     database.U256{Int: header.Number},
-					Timestamp:  header.Time,
-				},
-			})
+			indexedL1Headers = append(indexedL1Headers, &database.L1BlockHeader{BlockHeader: database.BlockHeaderFromGethHeader(header)})
 		}
 
 		/** Update Database **/
 
-		numL1Headers := len(l1Headers)
-		if numL1Headers == 0 {
-			processLog.Info("no l1 blocks of interest")
-			return nil
+		numIndexedL1Headers := len(indexedL1Headers)
+		if numIndexedL1Headers > 0 {
+			processLog.Info("saving l1 blocks with optimism logs", "size", numIndexedL1Headers, "batch_size", numHeaders)
+			err = db.Blocks.StoreL1BlockHeaders(indexedL1Headers)
+			if err != nil {
+				return err
+			}
+
+			// Since the headers to index are derived from the existence of logs, we know in this branch `numLogs > 0`
+			processLog.Info("detected contract logs", "size", len(l1ContractEvents))
+			err = db.ContractEvents.StoreL1ContractEvents(l1ContractEvents)
+			if err != nil {
+				return err
+			}
+
+			// Mark L2 checkpoints that have been recorded on L1 (L2OutputProposal & StateBatchAppended events)
+			numLegacyStateBatches := len(legacyStateBatches)
+			if numLegacyStateBatches > 0 {
+				latestBatch := legacyStateBatches[numLegacyStateBatches-1]
+				latestL2Height := latestBatch.PrevTotal + latestBatch.Size - 1
+				processLog.Info("detected legacy state batches", "size", numLegacyStateBatches, "latest_l2_block_number", latestL2Height)
+			}
+
+			numOutputProposals := len(outputProposals)
+			if numOutputProposals > 0 {
+				latestL2Height := outputProposals[numOutputProposals-1].L2BlockNumber.Int
+				processLog.Info("detected output proposals", "size", numOutputProposals, "latest_l2_block_number", latestL2Height)
+				err := db.Blocks.StoreOutputProposals(outputProposals)
+				if err != nil {
+					return err
+				}
+			}
+
+			// forward along contract events to the bridge processor
+			err = l1BridgeProcessContractEvents(processLog, db, ethClient, processedContractEvents, l1Contracts)
+			if err != nil {
+				return err
+			}
+		} else {
+			processLog.Info("no l1 blocks of interest within batch")
+		}
+
+		// a-ok!
+		return nil
+	}
+}
+
+func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethClient node.EthClient, events *ProcessedContractEvents, l1Contracts L1Contracts) error {
+	rawEthClient := ethclient.NewClient(ethClient.RawRpcClient())
+
+	// Process New Deposits
+	initiatedDepositEvents, err := StandardBridgeInitiatedEvents(events)
+	if err != nil {
+		return err
+	}
+
+	deposits := make([]*database.Deposit, len(initiatedDepositEvents))
+	for i, initiatedBridgeEvent := range initiatedDepositEvents {
+		deposits[i] = &database.Deposit{
+			GUID:                 uuid.New(),
+			InitiatedL1EventGUID: initiatedBridgeEvent.RawEvent.GUID,
+			SentMessageNonce:     database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
+			TokenPair:            database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
+			Tx: database.Transaction{
+				FromAddress: initiatedBridgeEvent.From,
+				ToAddress:   initiatedBridgeEvent.To,
+				Amount:      database.U256{Int: initiatedBridgeEvent.Amount},
+				Data:        initiatedBridgeEvent.ExtraData,
+				Timestamp:   initiatedBridgeEvent.RawEvent.Timestamp,
+			},
 		}
+	}
 
-		processLog.Info("saving l1 blocks of interest", "size", numL1Headers, "batch_size", numHeaders)
-		err = db.Blocks.StoreL1BlockHeaders(l1Headers)
+	if len(deposits) > 0 {
+		processLog.Info("detected L1StandardBridge deposits", "num", len(deposits))
+		err := db.Bridge.StoreDeposits(deposits)
 		if err != nil {
 			return err
 		}
+	}
 
-		// Since the headers to index are derived from the existence of logs, we know in this branch `numLogs > 0`
-		processLog.Info("saving contract logs", "size", numLogs)
-		err = db.ContractEvents.StoreL1ContractEvents(l1ContractEvents)
+	// Prove L2 Withdrawals
+	provenWithdrawalEvents, err := OptimismPortalWithdrawalProvenEvents(events)
+	if err != nil {
+		return err
+	}
+
+	// we manually keep track since not every proven withdrawal is a standard bridge withdrawal
+	numProvenWithdrawals := 0
+	for _, provenWithdrawalEvent := range provenWithdrawalEvents {
+		withdrawalHash := provenWithdrawalEvent.WithdrawalHash
+		withdrawal, err := db.Bridge.WithdrawalByHash(withdrawalHash)
 		if err != nil {
 			return err
 		}
 
-		// Mark L2 checkpoints that have been recorded on L1 (L2OutputProposal & StateBatchAppended events)
-		numLegacyStateBatches := len(legacyStateBatches)
-		if numLegacyStateBatches > 0 {
-			latestBatch := legacyStateBatches[numLegacyStateBatches-1]
-			latestL2Height := latestBatch.PrevTotal + latestBatch.Size - 1
-			processLog.Info("detected legacy state batches", "size", numLegacyStateBatches, "latest_l2_block_number", latestL2Height)
-		}
+		// Check if the L2Processor is behind or really has missed an event. We can compare against the
+		// OptimismPortal#ProvenWithdrawal on-chain mapping relative to the latest indexed L2 height
+		if withdrawal == nil {
+			bridgeAddress := l1Contracts.L1StandardBridge
+			portalAddress := l1Contracts.OptimismPortal
+			if provenWithdrawalEvent.From != bridgeAddress || provenWithdrawalEvent.To != bridgeAddress {
+				// non-bridge withdrawal
+				continue
+			}
 
-		numOutputProposals := len(outputProposals)
-		if numOutputProposals > 0 {
-			latestL2Height := outputProposals[numOutputProposals-1].L2BlockNumber.Int
-			processLog.Info("detected output proposals", "size", numOutputProposals, "latest_l2_block_number", latestL2Height)
-			err := db.Blocks.StoreOutputProposals(outputProposals)
+			// Query for the the proven withdrawal on-chain
+			provenWithdrawal, err := OptimismPortalQueryProvenWithdrawal(rawEthClient, portalAddress, withdrawalHash)
 			if err != nil {
 				return err
 			}
+
+			latestL2Header, err := db.Blocks.LatestL2BlockHeader()
+			if err != nil {
+				return err
+			}
+
+			if latestL2Header == nil || provenWithdrawal.L2OutputIndex.Cmp(latestL2Header.Number.Int) > 0 {
+				processLog.Warn("behind on indexed L2 withdrawals")
+				return errors.New("waiting for L2Processor to catch up")
+			} else {
+				processLog.Crit("missing indexed withdrawal for this proven event")
+				return errors.New("missing withdrawal message")
+			}
 		}
 
-		// a-ok!
-		return nil
+		err = db.Bridge.MarkProvenWithdrawalEvent(withdrawal.GUID, provenWithdrawalEvent.RawEvent.GUID)
+		if err != nil {
+			return err
+		}
+
+		numProvenWithdrawals++
+	}
+
+	if numProvenWithdrawals > 0 {
+		processLog.Info("proven L2StandardBridge withdrawals", "size", numProvenWithdrawals)
 	}
+
+	// Finalize Pending Withdrawals
+	finalizedWithdrawalEvents, err := StandardBridgeFinalizedEvents(rawEthClient, events)
+	if err != nil {
+		return err
+	}
+
+	for _, finalizedBridgeEvent := range finalizedWithdrawalEvents {
+		nonce := finalizedBridgeEvent.CrossDomainMessengerNonce
+		withdrawal, err := db.Bridge.WithdrawalByMessageNonce(nonce)
+		if err != nil {
+			processLog.Error("error querying associated withdrawal messsage using nonce", "cross_domain_messenger_nonce", nonce)
+			return err
+		}
+
+		// Since we have to prove the event on-chain first, we don't need to check if the processor is
+		// behind. we're definitely in an error state if we cannot find the withdrawal when parsing this even
+		if withdrawal == nil {
+			processLog.Crit("missing indexed withdrawal for this finalization event")
+			return errors.New("missing withdrawal message")
+		}
+
+		err = db.Bridge.MarkFinalizedWithdrawalEvent(withdrawal.GUID, finalizedBridgeEvent.RawEvent.GUID)
+		if err != nil {
+			processLog.Error("error finalizing withdrawal", "err", err)
+			return err
+		}
+	}
+
+	if len(finalizedWithdrawalEvents) > 0 {
+		processLog.Info("finalized L2StandardBridge withdrawals", "num", len(finalizedWithdrawalEvents))
+	}
+
+	// a-ok!
+	return nil
 }

indexer/processor/l2_processor.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/indexer/node"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/google/uuid"
 
 	"github.com/ethereum/go-ethereum"
@@ -124,8 +125,8 @@ func l2ProcessFn(processLog log.Logger, ethClient node.EthClient, l2Contracts L2
 			return err
 		}
 
-		numLogs := len(logs)
-		l2ContractEvents := make([]*database.L2ContractEvent, numLogs)
+		l2ContractEvents := make([]*database.L2ContractEvent, len(logs))
+		processedContractEvents := NewProcessedContractEvents()
 		for i, log := range logs {
 			header, ok := l2HeaderMap[log.BlockHash]
 			if !ok {
@@ -133,16 +134,8 @@ func l2ProcessFn(processLog log.Logger, ethClient node.EthClient, l2Contracts L2
 				return errors.New("parsed log with a block hash not in this batch")
 			}
 
-			l2ContractEvents[i] = &database.L2ContractEvent{
-				ContractEvent: database.ContractEvent{
-					GUID:            uuid.New(),
-					BlockHash:       log.BlockHash,
-					TransactionHash: log.TxHash,
-					EventSignature:  log.Topics[0],
-					LogIndex:        uint64(log.Index),
-					Timestamp:       header.Time,
-				},
-			}
+			contractEvent := processedContractEvents.AddLog(&logs[i], header.Time)
+			l2ContractEvents[i] = &database.L2ContractEvent{ContractEvent: *contractEvent}
 		}
 
 		/** Update Database **/
@@ -153,15 +146,118 @@ func l2ProcessFn(processLog log.Logger, ethClient node.EthClient, l2Contracts L2
 			return err
 		}
 
+		numLogs := len(l2ContractEvents)
 		if numLogs > 0 {
 			processLog.Info("detected contract logs", "size", numLogs)
 			err = db.ContractEvents.StoreL2ContractEvents(l2ContractEvents)
 			if err != nil {
 				return err
 			}
+
+			// forward along contract events to the bridge processor
+			err = l2BridgeProcessContractEvents(processLog, db, ethClient, processedContractEvents)
+			if err != nil {
+				return err
+			}
 		}
 
 		// a-ok!
 		return nil
 	}
 }
+
+func l2BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethClient node.EthClient, events *ProcessedContractEvents) error {
+	rawEthClient := ethclient.NewClient(ethClient.RawRpcClient())
+
+	l2ToL1MessagePasserABI, err := bindings.L2ToL1MessagePasserMetaData.GetAbi()
+	if err != nil {
+		return err
+	}
+
+	messagePassedEventAbi := l2ToL1MessagePasserABI.Events["MessagePassed"]
+
+	// Process New Withdrawals
+	initiatedWithdrawalEvents, err := StandardBridgeInitiatedEvents(events)
+	if err != nil {
+		return err
+	}
+
+	withdrawals := make([]*database.Withdrawal, len(initiatedWithdrawalEvents))
+	for i, initiatedBridgeEvent := range initiatedWithdrawalEvents {
+		log := events.eventLog[initiatedBridgeEvent.RawEvent.GUID]
+
+		// extract the withdrawal hash from the MessagePassed event
+		var msgPassedData bindings.L2ToL1MessagePasserMessagePassed
+		msgPassedLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GUID]
+		err := UnpackLog(&msgPassedData, msgPassedLog, messagePassedEventAbi.Name, l2ToL1MessagePasserABI)
+		if err != nil {
+			return err
+		}
+
+		withdrawals[i] = &database.Withdrawal{
+			GUID:                 uuid.New(),
+			InitiatedL2EventGUID: initiatedBridgeEvent.RawEvent.GUID,
+			SentMessageNonce:     database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
+			WithdrawalHash:       msgPassedData.WithdrawalHash,
+			TokenPair:            database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
+			Tx: database.Transaction{
+				FromAddress: initiatedBridgeEvent.From,
+				ToAddress:   initiatedBridgeEvent.To,
+				Amount:      database.U256{Int: initiatedBridgeEvent.Amount},
+				Data:        initiatedBridgeEvent.ExtraData,
+				Timestamp:   initiatedBridgeEvent.RawEvent.Timestamp,
+			},
+		}
+	}
+
+	if len(withdrawals) > 0 {
+		processLog.Info("detected L2StandardBridge withdrawals", "num", len(withdrawals))
+		err := db.Bridge.StoreWithdrawals(withdrawals)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Finalize Deposits
+	finalizationBridgeEvents, err := StandardBridgeFinalizedEvents(rawEthClient, events)
+	if err != nil {
+		return err
+	}
+
+	for _, finalizedBridgeEvent := range finalizationBridgeEvents {
+		nonce := finalizedBridgeEvent.CrossDomainMessengerNonce
+
+		deposit, err := db.Bridge.DepositByMessageNonce(nonce)
+		if err != nil {
+			processLog.Error("error querying associated deposit messsage using nonce", "cross_domain_messenger_nonce", nonce)
+			return err
+		} else if deposit == nil {
+			latestNonce, err := db.Bridge.LatestDepositMessageNonce()
+			if err != nil {
+				return err
+			}
+
+			// Check if the L1Processor is behind or really has missed an event
+			if latestNonce == nil || nonce.Cmp(latestNonce) > 0 {
+				processLog.Warn("behind on indexed L1 deposits")
+				return errors.New("waiting for L1Processor to catch up")
+			} else {
+				processLog.Crit("missing indexed deposit for this finalization event")
+				return errors.New("missing deposit message")
+			}
+		}
+
+		err = db.Bridge.MarkFinalizedDepositEvent(deposit.GUID, finalizedBridgeEvent.RawEvent.GUID)
+		if err != nil {
+			processLog.Error("error finalizing deposit", "err", err)
+			return err
+		}
+	}
+
+	if len(finalizationBridgeEvents) > 0 {
+		processLog.Info("finalized L1StandardBridge deposits", "size", len(finalizationBridgeEvents))
+	}
+
+	// a-ok
+	return nil
+}

indexer/processor/optimism_portal.go

+package processor
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+)
+
+type OptimismPortalWithdrawalProvenEvent struct {
+	*bindings.OptimismPortalWithdrawalProven
+
+	RawEvent *database.ContractEvent
+}
+
+type OptimismPortalProvenWithdrawal struct {
+	OutputRoot    [32]byte
+	Timestamp     *big.Int
+	L2OutputIndex *big.Int
+}
+
+func OptimismPortalWithdrawalProvenEvents(events *ProcessedContractEvents) ([]OptimismPortalWithdrawalProvenEvent, error) {
+	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	processedWithdrawalProvenEvents := events.eventsBySignature[optimismPortalAbi.Events["WithdrawalProven"].ID]
+	provenEvents := make([]OptimismPortalWithdrawalProvenEvent, len(processedWithdrawalProvenEvents))
+	for i, provenEvent := range processedWithdrawalProvenEvents {
+
+		provenEvents[i] = OptimismPortalWithdrawalProvenEvent{nil, provenEvent}
+	}
+
+	return provenEvents, nil
+}
+
+func OptimismPortalQueryProvenWithdrawal(ethClient *ethclient.Client, portalAddress common.Address, withdrawalHash common.Hash) (OptimismPortalProvenWithdrawal, error) {
+	var provenWithdrawal OptimismPortalProvenWithdrawal
+
+	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
+	if err != nil {
+		return provenWithdrawal, err
+	}
+
+	name := "provenWithdrawals"
+	txData, err := optimismPortalAbi.Pack(name, withdrawalHash)
+	if err != nil {
+		return provenWithdrawal, err
+	}
+
+	callMsg := ethereum.CallMsg{To: &portalAddress, Data: txData}
+	data, err := ethClient.CallContract(context.Background(), callMsg, nil)
+	if err != nil {
+		return provenWithdrawal, err
+	}
+
+	err = optimismPortalAbi.UnpackIntoInterface(&provenWithdrawal, name, data)
+	if err != nil {
+		return provenWithdrawal, err
+	}
+
+	return provenWithdrawal, nil
+}

indexer/processor/processor.go

@@ -55,8 +55,8 @@ func (p processor) Start() {
 		firstHeader := unprocessedHeaders[0]
 		lastHeader := unprocessedHeaders[len(unprocessedHeaders)-1]
 		batchLog := p.processLog.New("batch_start_block_number", firstHeader.Number, "batch_end_block_number", lastHeader.Number)
-		batchLog.Info("processing batch")
 		err := p.db.Transaction(func(db *database.DB) error {
+			batchLog.Info("processing batch")
 			return p.processFn(db, unprocessedHeaders)
 		})
 

indexer/processor/standard_bridge.go

+package processor
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+)
+
+var (
+	ethAddress = common.HexToAddress("0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000")
+)
+
+type StandardBridgeInitiatedEvent struct {
+	// We hardcode to ERC20 since ETH can be pseudo-represented as an ERC20 utilizing
+	// the hardcoded ETH address
+	*bindings.L1StandardBridgeERC20BridgeInitiated
+
+	CrossDomainMessengerNonce *big.Int
+	RawEvent                  *database.ContractEvent
+}
+
+type StandardBridgeFinalizedEvent struct {
+	// We hardcode to ERC20 since ETH can be pseudo-represented as an ERC20 utilizing
+	// the hardcoded ETH address
+	*bindings.L1StandardBridgeERC20BridgeFinalized
+
+	CrossDomainMessengerNonce *big.Int
+	RawEvent                  *database.ContractEvent
+}
+
+// StandardBridgeInitiatedEvents extracts all initiated bridge events from the contracts that follow the StandardBridge ABI. The
+// correlated CrossDomainMessenger nonce is also parsed from the associated messenger events.
+func StandardBridgeInitiatedEvents(events *ProcessedContractEvents) ([]StandardBridgeInitiatedEvent, error) {
+	ethBridgeInitiatedEvents, err := _standardBridgeInitiatedEvents[bindings.L1StandardBridgeETHBridgeInitiated](events)
+	if err != nil {
+		return nil, err
+	}
+
+	erc20BridgeInitiatedEvents, err := _standardBridgeInitiatedEvents[bindings.L1StandardBridgeERC20BridgeInitiated](events)
+	if err != nil {
+		return nil, err
+	}
+
+	return append(ethBridgeInitiatedEvents, erc20BridgeInitiatedEvents...), nil
+}
+
+// StandardBridgeFinalizedEvents extracts all finalization bridge events from the contracts that follow the StandardBridge ABI. The
+// correlated CrossDomainMessenger nonce is also parsed by looking at the parameters of the corresponding relayMessage transaction data.
+func StandardBridgeFinalizedEvents(rawEthClient *ethclient.Client, events *ProcessedContractEvents) ([]StandardBridgeFinalizedEvent, error) {
+	ethBridgeFinalizedEvents, err := _standardBridgeFinalizedEvents[bindings.L1StandardBridgeETHBridgeFinalized](rawEthClient, events)
+	if err != nil {
+		return nil, err
+	}
+
+	erc20BridgeFinalizedEvents, err := _standardBridgeFinalizedEvents[bindings.L1StandardBridgeERC20BridgeFinalized](rawEthClient, events)
+	if err != nil {
+		return nil, err
+	}
+
+	return append(ethBridgeFinalizedEvents, erc20BridgeFinalizedEvents...), nil
+}
+
+// parse out eth or erc20 bridge initiated events
+func _standardBridgeInitiatedEvents[BridgeEvent bindings.L1StandardBridgeETHBridgeInitiated | bindings.L1StandardBridgeERC20BridgeInitiated](
+	events *ProcessedContractEvents,
+) ([]StandardBridgeInitiatedEvent, error) {
+	l1StandardBridgeABI, err := bindings.L1StandardBridgeMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	l1CrossDomainMessengerABI, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	sentMessageEventAbi := l1CrossDomainMessengerABI.Events["SentMessage"]
+
+	var tmp BridgeEvent
+	var eventName string
+	var finalizeMethodName string
+	switch any(tmp).(type) {
+	case bindings.L1StandardBridgeETHBridgeInitiated:
+		eventName = "ETHBridgeInitiated"
+		finalizeMethodName = "finalizeBridgeETH"
+	case bindings.L1StandardBridgeERC20BridgeInitiated:
+		eventName = "ERC20BridgeInitiated"
+		finalizeMethodName = "finalizeBridgeERC20"
+	default:
+		panic("should not be here")
+	}
+
+	processedInitiatedBridgeEvents := events.eventsBySignature[l1StandardBridgeABI.Events[eventName].ID]
+	initiatedBridgeEvents := make([]StandardBridgeInitiatedEvent, len(processedInitiatedBridgeEvents))
+	for i, bridgeInitiatedEvent := range processedInitiatedBridgeEvents {
+		log := events.eventLog[bridgeInitiatedEvent.GUID]
+
+		bridgeData := new(BridgeEvent)
+		err := UnpackLog(bridgeData, log, eventName, l1StandardBridgeABI)
+		if err != nil {
+			return nil, err
+		}
+
+		// Look for the sent message event to extract the associated messager nonce
+		//   - L1: BridgeInitiated -> Portal#DepositTransaction -> SentMessage ...
+		//   - L1: BridgeInitiated -> L2ToL1MessagePasser#MessagePassed -> SentMessage ...
+		var sentMsgData bindings.L1CrossDomainMessengerSentMessage
+		sentMsgLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 2}].GUID]
+		err = UnpackLog(&sentMsgData, sentMsgLog, sentMessageEventAbi.Name, l1CrossDomainMessengerABI)
+		if err != nil {
+			return nil, err
+		}
+
+		var erc20BridgeData *bindings.L1StandardBridgeERC20BridgeInitiated
+		var expectedCrossDomainMessage []byte
+		switch any(bridgeData).(type) {
+		case *bindings.L1StandardBridgeETHBridgeInitiated:
+			ethBridgeData := any(bridgeData).(*bindings.L1StandardBridgeETHBridgeInitiated)
+			expectedCrossDomainMessage, err = l1StandardBridgeABI.Pack(finalizeMethodName, ethBridgeData.From, ethBridgeData.To, ethBridgeData.Amount, ethBridgeData.ExtraData)
+			if err != nil {
+				return nil, err
+			}
+
+			// represent eth bridge as an erc20
+			erc20BridgeData = &bindings.L1StandardBridgeERC20BridgeInitiated{
+				// Represent ETH using the hardcoded address
+				LocalToken: ethAddress, RemoteToken: ethAddress,
+				// Bridge data
+				From: ethBridgeData.From, To: ethBridgeData.To, Amount: ethBridgeData.Amount, ExtraData: ethBridgeData.ExtraData,
+			}
+
+		case *bindings.L1StandardBridgeERC20BridgeInitiated:
+			_temp := any(bridgeData).(bindings.L1StandardBridgeERC20BridgeInitiated)
+			erc20BridgeData = &_temp
+			expectedCrossDomainMessage, err = l1StandardBridgeABI.Pack(finalizeMethodName, erc20BridgeData.RemoteToken, erc20BridgeData.LocalToken, erc20BridgeData.From, erc20BridgeData.To, erc20BridgeData.Amount, erc20BridgeData.ExtraData)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		if !bytes.Equal(sentMsgData.Message, expectedCrossDomainMessage) {
+			return nil, errors.New("bridge cross domain message mismatch")
+		}
+
+		initiatedBridgeEvents[i] = StandardBridgeInitiatedEvent{erc20BridgeData, sentMsgData.MessageNonce, bridgeInitiatedEvent}
+	}
+
+	return initiatedBridgeEvents, nil
+}
+
+// parse out eth or erc20 bridge finalization events
+func _standardBridgeFinalizedEvents[BridgeEvent bindings.L1StandardBridgeETHBridgeFinalized | bindings.L1StandardBridgeERC20BridgeFinalized](
+	rawEthClient *ethclient.Client,
+	events *ProcessedContractEvents,
+) ([]StandardBridgeFinalizedEvent, error) {
+	l1StandardBridgeABI, err := bindings.L1StandardBridgeMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	l1CrossDomainMessengerABI, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	relayedMessageEventAbi := l1CrossDomainMessengerABI.Events["RelayedMessage"]
+	relayMessageMethodAbi := l1CrossDomainMessengerABI.Methods["relayMessage"]
+
+	var bridgeData BridgeEvent
+	var eventName string
+	switch any(bridgeData).(type) {
+	case bindings.L1StandardBridgeETHBridgeFinalized:
+		eventName = "ETHBridgeFinalized"
+	case bindings.L1StandardBridgeERC20BridgeFinalized:
+		eventName = "ERC20BridgeFinalized"
+	default:
+		panic("should not be here")
+	}
+
+	processedFinalizedBridgeEvents := events.eventsBySignature[l1StandardBridgeABI.Events[eventName].ID]
+	finalizedBridgeEvents := make([]StandardBridgeFinalizedEvent, len(processedFinalizedBridgeEvents))
+	for i, bridgeFinalizedEvent := range processedFinalizedBridgeEvents {
+		log := events.eventLog[bridgeFinalizedEvent.GUID]
+
+		var bridgeData BridgeEvent
+		err := UnpackLog(&bridgeData, log, eventName, l1StandardBridgeABI)
+		if err != nil {
+			return nil, err
+		}
+
+		// Look for the RelayedMessage event that follows right after the BridgeFinalized Event
+		relayedMsgLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GUID]
+		if relayedMsgLog.Topics[0] != relayedMessageEventAbi.ID {
+			return nil, errors.New("unexpected bridge event ordering")
+		}
+
+		// There's no way to extract the nonce on the relayed message event. we can extract
+		// the nonce by unpacking the transaction input for the `relayMessage` transaction
+		tx, isPending, err := rawEthClient.TransactionByHash(context.Background(), relayedMsgLog.TxHash)
+		if err != nil || isPending {
+			return nil, errors.New("unable to query relayMessage tx for bridge finalization event")
+		}
+
+		txData := tx.Data()
+		if !bytes.Equal(txData[:4], relayMessageMethodAbi.ID) {
+			return nil, errors.New("bridge finalization event does not match relayMessage tx invocation")
+		}
+
+		inputsMap := make(map[string]interface{})
+		err = relayMessageMethodAbi.Inputs.UnpackIntoMap(inputsMap, txData[4:])
+		if err != nil {
+			return nil, err
+		}
+
+		nonce, ok := inputsMap["_nonce"].(*big.Int)
+		if !ok {
+			return nil, errors.New("unable to extract `_nonce` parameter from relayMessage transaction")
+		}
+
+		var erc20BridgeData *bindings.L1StandardBridgeERC20BridgeFinalized
+		switch any(bridgeData).(type) {
+		case bindings.L1StandardBridgeETHBridgeInitiated:
+			ethBridgeData := any(bridgeData).(bindings.L1StandardBridgeETHBridgeFinalized)
+			erc20BridgeData = &bindings.L1StandardBridgeERC20BridgeFinalized{
+				// Represent ETH using the hardcoded address
+				LocalToken: ethAddress, RemoteToken: ethAddress,
+				// Bridge data
+				From: ethBridgeData.From, To: ethBridgeData.To, Amount: ethBridgeData.Amount, ExtraData: ethBridgeData.ExtraData,
+			}
+
+		case bindings.L1StandardBridgeERC20BridgeInitiated:
+			_temp := any(bridgeData).(bindings.L1StandardBridgeERC20BridgeFinalized)
+			erc20BridgeData = &_temp
+		}
+
+		finalizedBridgeEvents[i] = StandardBridgeFinalizedEvent{erc20BridgeData, nonce, bridgeFinalizedEvent}
+	}
+
+	return finalizedBridgeEvents, nil
+}

nx.json

@@ -4,7 +4,12 @@
     "defaultBase": "develop"
   },
   "implicitDependencies": {
-    "nx.json": "*"
+    "nx.json": "*",
+    "tsconfig.json": "*",
+    ".foundryrc": "*",
+    "pnpm.lock.yaml": "*",
+    ".npmrc": "*",
+    ".nvmrc":  "*"
   },
   "tasksRunnerOptions": {
     "default": {

op-bindings/bindings/mips.go

@@ -30,8 +30,8 @@ var (
 
 // MIPSMetaData contains all meta data concerning the MIPS contract.
 var MIPSMetaData = &bind.MetaData{
-	ABI: "[{\"inputs\":[],\"name\":\"BRK_START\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"stateData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"proof\",\"type\":\"bytes\"}],\"name\":\"Step\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"oracle\",\"outputs\":[{\"internalType\":\"contractIPreimageOracle\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
-	Bin: "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",
+	ABI: "[{\"inputs\":[],\"name\":\"BRK_START\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"oracle\",\"outputs\":[{\"internalType\":\"contractIPreimageOracle\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"stateData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"proof\",\"type\":\"bytes\"}],\"name\":\"step\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
+	Bin: "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",
 }
 
 // MIPSABI is the input ABI used to generate the binding from.
@@ -263,23 +263,23 @@ func (_MIPS *MIPSCallerSession) Oracle() (common.Address, error) {
 	return _MIPS.Contract.Oracle(&_MIPS.CallOpts)
 }
 
-// Step is a paid mutator transaction binding the contract method 0x98bb1383.
+// Step is a paid mutator transaction binding the contract method 0xf8e0cb96.
 //
-// Solidity: function Step(bytes stateData, bytes proof) returns(bytes32)
+// Solidity: function step(bytes stateData, bytes proof) returns(bytes32)
 func (_MIPS *MIPSTransactor) Step(opts *bind.TransactOpts, stateData []byte, proof []byte) (*types.Transaction, error) {
-	return _MIPS.contract.Transact(opts, "Step", stateData, proof)
+	return _MIPS.contract.Transact(opts, "step", stateData, proof)
 }
 
-// Step is a paid mutator transaction binding the contract method 0x98bb1383.
+// Step is a paid mutator transaction binding the contract method 0xf8e0cb96.
 //
-// Solidity: function Step(bytes stateData, bytes proof) returns(bytes32)
+// Solidity: function step(bytes stateData, bytes proof) returns(bytes32)
 func (_MIPS *MIPSSession) Step(stateData []byte, proof []byte) (*types.Transaction, error) {
 	return _MIPS.Contract.Step(&_MIPS.TransactOpts, stateData, proof)
 }
 
-// Step is a paid mutator transaction binding the contract method 0x98bb1383.
+// Step is a paid mutator transaction binding the contract method 0xf8e0cb96.
 //
-// Solidity: function Step(bytes stateData, bytes proof) returns(bytes32)
+// Solidity: function step(bytes stateData, bytes proof) returns(bytes32)
 func (_MIPS *MIPSTransactorSession) Step(stateData []byte, proof []byte) (*types.Transaction, error) {
 	return _MIPS.Contract.Step(&_MIPS.TransactOpts, stateData, proof)
 }

op-bindings/bindings/mips_more.go

@@ -13,7 +13,7 @@ const MIPSStorageLayoutJSON = "{\"storage\":[{\"astId\":1000,\"contract\":\"cont
 
 var MIPSStorageLayout = new(solc.StorageLayout)
 
-var MIPSDeployedBin = "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"
+var MIPSDeployedBin = "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"
 
 var MIPSDeployedSourceMap = "1025:22415:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1423:45;;;:::i;:::-;;;;;;;;;;;;;;;;;;;1791:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;14376:4789;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14376:4789:0;;-1:-1:-1;14376:4789:0;-1:-1:-1;14376:4789:0;:::i;:::-;;;;;;;;;;;;;;;;1423:45;1458:10;1423:45;:::o;1791:29::-;;;;;;:::o;14376:4789::-;14454:7;14469:18;;:::i;:::-;14569:4;14562:5;14559:15;14549:2;;14630:1;14628;14621:11;14549:2;14666:4;14660:11;14673;14657:28;14647:2;;14731:1;14729;14722:11;14647:2;14779:3;14761:16;14758:25;14748:2;;14845:1;14843;14836:11;14748:2;14889:3;14875:12;14872:21;14862:2;;14954:1;14952;14945:11;14862:2;14971:370;;;15189:24;;15177:2;15173:13;;;15170:1;15166:21;15162:52;;;;15223:20;;15269:21;;;15315:18;;;15049:292::o;:::-;15357:16;15408:4;15441:18;15456:2;15453:1;15450;15441:18;:::i;:::-;15433:26;;;;15485:18;15500:2;15497:1;15494;15485:18;:::i;:::-;15477:26;;;;15533:17;15548:1;15545;15542;15533:17;:::i;:::-;15525:25;;;;15583:17;15598:1;15595;15592;15583:17;:::i;:::-;15575:25;;;;15621:17;15636:1;15633;15630;15621:17;:::i;:::-;15613:25;;;;15663:17;15678:1;15675;15672;15663:17;:::i;:::-;15655:25;;;;15701:17;15716:1;15713;15710;15701:17;:::i;:::-;15693:25;;;;15739:17;15754:1;15751;15748;15739:17;:::i;:::-;15731:25;;;;15779:17;15794:1;15791;15788;15779:17;:::i;:::-;15771:25;;;;15823:17;15838:1;15835;15832;15823:17;:::i;:::-;15815:25;;;;15865:17;15880:1;15877;15874;15865:17;:::i;:::-;15914:2;15907:10;;15897:21;;;;15857:25;;-1:-1:-1;15907:10:0;-1:-1:-1;15985:1:0;15970:77;15995:2;15992:1;15989:9;15970:77;;;16028:17;16043:1;16040;16037;16028:17;:::i;:::-;16020:25;;-1:-1:-1;16020:25:0;-1:-1:-1;16013:1:0;16006:9;15970:77;;;15974:14;;;16074:5;:12;;;16071:86;;;16137:13;:11;:13::i;:::-;16130:20;;;;;16071:86;16162:10;;;:15;;16176:1;16162:15;;;;;16231:8;;;;-1:-1:-1;;16223:20:0;;-1:-1:-1;16223:7:0;:20::i;:::-;16209:34;-1:-1:-1;16266:10:0;16274:2;16266:10;;;;16327:1;16317:11;;;:26;;;16332:6;:11;;16342:1;16332:11;16317:26;16313:308;;;16552:62;16563:6;:11;;16573:1;16563:11;:20;;16581:2;16563:20;;;16577:1;16563:20;16552:62;;16612:1;16585:23;16588:4;16593:10;16588:15;16605:2;16585;:23::i;:::-;:28;;;;16552:10;:62::i;:::-;16545:69;;;;;;;16313:308;16822:15;;;;16649:9;;;;16770:4;16764:2;16756:10;;;16755:19;;;16822:15;16847:2;16839:10;;;16838:19;16822:36;;;;;;;;;;;;-1:-1:-1;16879:5:0;16894:11;;;;;:29;;;16909:6;:14;;16919:4;16909:14;16894:29;16890:636;;;16966:5;:15;;;16982:5;16966:22;;;;;;;;;;;;;;-1:-1:-1;;17019:4:0;17013:2;17005:10;;;17004:19;16890:636;;;17049:4;17040:6;:13;;;17036:490;;;17140:6;:13;;17150:3;17140:13;:30;;;;17157:6;:13;;17167:3;17157:13;17140:30;:47;;;;17174:6;:13;;17184:3;17174:13;17140:47;17136:181;;;17226:4;17231:6;17226:11;17221:16;;17136:181;;;17289:19;17292:4;17297:6;17292:11;17305:2;17289;:19::i;:::-;17284:24;;17136:181;17036:490;;;17343:4;17333:6;:14;;;;:32;;;;17351:6;:14;;17361:4;17351:14;17333:32;:50;;;;17369:6;:14;;17379:4;17369:14;17333:50;17329:197;;;17433:5;:15;;;17449:5;17433:22;;;;;;;;;;;;;17428:27;;17514:5;17506:13;;17329:197;17547:1;17537:6;:11;;;;:25;;;;;17561:1;17552:6;:10;;;17537:25;17536:42;;;;17567:6;:11;;17577:1;17567:11;17536:42;17532:107;;;17595:37;17608:6;17616:4;17622:5;17629:2;17595:12;:37::i;:::-;17588:44;;;;;;;;;;;17532:107;17664:13;17645:16;17784:4;17774:14;;;;17770:328;;17833:19;17836:4;17841:6;17836:11;17849:2;17833;:19::i;:::-;17827:25;;;;17879:10;17874:15;;17903:16;17874:15;17917:1;17903:7;:16::i;:::-;17897:22;;17941:4;17931:6;:14;;;;:32;;;;;17949:6;:14;;17959:4;17949:14;;17931:32;17927:165;;;18004:4;17992:16;;18082:1;18074:9;;17927:165;17770:328;;18115:10;18128:26;18136:4;18142:2;18146;18150:3;18128:7;:26::i;:::-;18157:10;18128:39;;;;-1:-1:-1;18245:4:0;18238:11;;;18269;;;:24;;;;;18292:1;18284:4;:9;;;;18269:24;:39;;;;;18304:4;18297;:11;;;18269:39;18265:589;;;18322:4;:9;;18330:1;18322:9;:22;;;;18335:4;:9;;18343:1;18335:9;18322:22;18318:102;;;18374:37;18385:4;:9;;18393:1;18385:9;:21;;18401:5;18385:21;;;18397:1;18385:21;18408:2;18374:10;:37::i;:::-;18367:44;;;;;;;;;;;;;;;18318:102;18432:4;:11;;18440:3;18432:11;18428:79;;;18470:28;18479:5;18486:2;18490:7;;;;18470:8;:28::i;18428:79::-;18518:4;:11;;18526:3;18518:11;18514:79;;;18556:28;18565:5;18572:2;18576:7;;;;;18556:8;:28::i;18514:79::-;18643:4;:11;;18651:3;18643:11;18639:58;;;18673:15;:13;:15::i;18639:58::-;18770:4;18762;:12;;;;:27;;;;;18785:4;18778;:11;;;18762:27;18758:90;;;18808:31;18819:4;18825:2;18829;18833:5;18808:10;:31::i;18758:90::-;18898:6;:14;;18908:4;18898:14;:28;;;;-1:-1:-1;18916:10:0;;;;;18898:28;18894:75;;;18961:1;18936:5;:15;;;18952:5;18936:22;;;;;;;;;:26;;;;:22;;;;;;:26;18894:75;18999:9;:26;;19012:13;18999:26;18995:74;;19035:27;19044:9;19055:1;19058:3;19035:8;:27::i;:::-;19134:26;19143:5;19150:3;19155:4;19134:8;:26::i;:::-;19127:33;;;;;;;;;;;;;14376:4789;;;;;;;:::o;2085:1331::-;2126:11;2254:176;;;2346:2;2342:13;;;2332:24;;2326:31;2315:43;;2378:13;;2409;;;2305:125::o;:::-;2449:4;2488;2482:11;2526:5;2550:21;2568:2;2564;2558:4;2550:21;:::i;:::-;2538:33;;;;2601:21;2619:2;2615;2609:4;2601:21;:::i;:::-;2589:33;;;;2656:20;2674:1;2670:2;2664:4;2656:20;:::i;:::-;2644:32;;;;2713:20;2731:1;2727:2;2721:4;2713:20;:::i;:::-;2701:32;;;;2758:20;2776:1;2772:2;2766:4;2758:20;:::i;:::-;2746:32;;;;2807:20;2825:1;2821:2;2815:4;2807:20;:::i;:::-;2795:32;;;;2852:20;2870:1;2866:2;2860:4;2852:20;:::i;:::-;2840:32;;;;2897:20;2915:1;2911:2;2905:4;2897:20;:::i;:::-;2885:32;;;;2944:20;2962:1;2958:2;2952:4;2944:20;:::i;:::-;2932:32;;;;2995:20;3013:1;3009:2;3003:4;2995:20;:::i;:::-;2983:32;;;;3044:20;3062:1;3058:2;3052:4;3044:20;:::i;:::-;3097:2;3087:13;;;;-1:-1:-1;3032:32:0;-1:-1:-1;3145:1:0;3130:84;3155:2;3152:1;3149:9;3130:84;;;3192:20;3210:1;3206:2;3200:4;3192:20;:::i;:::-;3180:32;;-1:-1:-1;3180:32:0;-1:-1:-1;3173:1:0;3166:9;3130:84;;;3134:14;3245:1;3241:2;3234:13;3290:5;3286:2;3282:14;3275:5;3270:27;3375:14;;;3358:32;;;-1:-1:-1;;2085:1331:0;;:::o;11778:1270::-;11849:10;11867:14;11884:23;11896:10;11884:11;:23::i;:::-;11867:40;;11943:1;11937:4;11933:12;11930:2;;;11958:1;11955;11948:12;11930:2;12060;12048:15;;;12011:20;12070:169;;;;12109:12;;;12195:2;12188:13;;;;12228:2;12215:16;;;12099:140::o;:::-;12265:4;12262:1;12258:12;12289:4;12412:1;12397:273;12422:2;12419:1;12416:9;12397:273;;;12521:2;12509:15;;;12470:20;12544:12;;;12558:1;12540:20;12569:42;;;;12625:1;12620:42;;;;12533:129;;12569:42;12586:23;12601:7;12595:4;12586:23;:::i;:::-;12578:31;;12569:42;;12620;12637:23;12655:4;12646:7;12637:23;:::i;:::-;12629:31;;12533:129;-1:-1:-1;;12440:1:0;12433:9;12397:273;;;12401:14;12698:4;12692:11;12677:26;;12767:7;12761:4;12758:17;12748:2;;12824:10;12821:1;12814:21;12854:2;12851:1;12844:13;12748:2;-1:-1:-1;;12970:2:0;12960:13;;12948:10;12944:30;12941:1;12937:38;12993:16;13011:10;12989:33;;-1:-1:-1;;11778:1270:0;;;;:::o;1825:256::-;1884:6;1915:14;;;;1923:5;;;;1915:14;;;;;;1914:21;;;;;1927:1;1966:2;:6;;;1960:13;;;;;1959:19;;1958:28;;;;;;;2008:8;;2007:14;1914:21;2053;;2073:1;2053:21;;;2064:6;2053:21;2041:8;;;;;:34;;-1:-1:-1;;;1825:256:0;;;;:::o;10450:401::-;10517:7;10532:18;;:::i;:::-;-1:-1:-1;10613:8:0;;;10638:12;;;10627:23;;;;;;;10656:19;;;;;10582:4;;10685:12;;;10681:140;;10734:6;10741:1;10734:8;10707:5;:15;;;10723:7;10707:24;;;;;;;;;:35;;;;:24;;;;;;:35;10681:140;10833:13;:11;:13::i;:::-;10826:20;10450:401;-1:-1:-1;;;;;10450:401:0:o;8292:1063::-;8385:7;8400:18;;:::i;:::-;-1:-1:-1;8450:4:0;8465:17;8511:1;8501:11;;;;;:26;;;8516:6;:11;;8526:1;8516:11;8501:26;8497:514;;;8550:9;8562:5;:15;;;8578:5;8562:22;;;;;;;;;;;;;8550:34;;8614:2;8608:8;;:2;:8;;;:23;;;;;8620:6;:11;;8630:1;8620:11;8608:23;8607:54;;;;8643:2;8637:8;;:2;:8;;;;:23;;;;;8649:6;:11;;8659:1;8649:11;8637:23;8592:69;;8497:514;;;;8678:6;:11;;8688:1;8678:11;8674:337;;;8721:1;8714:2;8708:14;;;;8693:29;;8674:337;;;8747:6;:11;;8757:1;8747:11;8743:268;;;8789:1;8783:2;8777:13;;;8762:28;;8743:268;;;8815:6;:11;;8825:1;8815:11;8811:200;;;8881:4;8875:2;8867:10;;;8866:19;8898:8;8894:42;;8935:1;8929:2;8923:13;;;8908:28;;8894:42;8957:3;:8;;8964:1;8957:8;8953:43;;;8995:1;8988:2;8982:14;;;;8967:29;;8953:43;8811:200;;9033:8;;;;;9058:12;;;;9047:23;;;;;9108:216;;;;9184:1;9163:19;9166:4;9171:6;9166:11;9179:2;9163;:19::i;:::-;:22;;;;;;;9149:37;;9158:1;9149:37;9134:52;:12;;;:52;9108:216;;;9281:12;;;;;9296:1;9281:16;9266:31;;;;9108:216;9337:13;:11;:13::i;:::-;9330:20;8292:1063;-1:-1:-1;;;;;;;;8292:1063:0:o;19169:4269::-;19256:6;19286:10;19294:2;19286:10;;;;;;19329:11;;19425:4;19416:13;;19412:3986;;;19526:1;19516:6;:11;;;;:27;;;;;19540:3;19531:6;:12;;;19516:27;19512:462;;;19559:6;:11;;19569:1;19559:11;19555:383;;;-1:-1:-1;19581:4:0;19555:383;;;19621:6;:11;;19631:1;19621:11;19617:321;;;-1:-1:-1;19643:4:0;19617:321;;;19679:6;:13;;19689:3;19679:13;19675:263;;;-1:-1:-1;19703:4:0;19675:263;;;19736:6;:13;;19746:3;19736:13;19732:206;;;-1:-1:-1;19760:4:0;19732:206;;;19794:6;:13;;19804:3;19794:13;19790:148;;;-1:-1:-1;19818:4:0;19790:148;;;19851:6;:13;;19861:3;19851:13;19847:91;;;-1:-1:-1;19875:4:0;19847:91;;;19907:6;:13;;19917:3;19907:13;19903:35;;;-1:-1:-1;19931:4:0;19903:35;19964:1;19955:10;;19512:462;20015:11;;;20011:1701;;20067:4;20062:1;20054:9;;;20053:18;20092:4;20054:9;20085:11;;;20081:588;;;20122:4;20114;:12;;;20110:549;;20137:2;20130:9;;;;;;;20110:549;20217:12;;;20213:446;;20240:11;;;;;;;;-1:-1:-1;20233:18:0;;-1:-1:-1;;20233:18:0;20213:446;20286:4;:12;;20294:4;20286:12;20282:377;;;20309:11;;;;;;;;-1:-1:-1;20302:18:0;;-1:-1:-1;;20302:18:0;20282:377;20355:4;:12;;20363:4;20355:12;20351:308;;;20378:25;20387:5;20381:11;;:2;:11;;;;20397:5;20394:2;:8;20378:2;:25::i;20351:308::-;20438:4;:12;;20446:4;20438:12;20434:225;;;-1:-1:-1;;;;20461:15:0;;;20471:4;20468:7;;20461:15;20454:22;;20434:225;20515:4;:12;;20523:4;20515:12;20511:148;;;-1:-1:-1;;;;20538:15:0;;;20548:4;20545:7;;20538:15;20531:22;;20511:148;20592:4;:12;;20600:4;20592:12;20588:71;;;20615:19;20624:2;20618:8;;:2;:8;;;;20631:2;20628;:5;20615:2;:19::i;20588:71::-;20757:4;:12;;20765:4;20757:12;:28;;;;20773:4;:12;;20781:4;20773:12;20757:28;20753:602;;;20799:2;20796;:5;20789:12;;;;;;;20753:602;20839:4;:12;;20847:4;20839:12;:28;;;;20855:4;:12;;20863:4;20855:12;20839:28;20835:520;;;20881:2;20878;:5;20871:12;;;;;;;20835:520;20921:4;:12;;20929:4;20921:12;20917:438;;;20947:2;20944;:5;20937:12;;;;;;;20917:438;20988:4;:12;;20996:4;20988:12;20984:371;;;21015:2;21012;:5;21004:14;;;;;;;20984:371;21054:4;:12;;21062:4;21054:12;21050:305;;;21081:2;21078;:5;21070:14;;;;;;;21050:305;21121:4;:12;;21129:4;21121:12;21117:238;;;-1:-1:-1;;;;21146:5:0;;;21144:8;21137:15;;21117:238;21188:4;:12;;21196:4;21188:12;21184:171;;;21237:2;21221:19;;21227:2;21221:19;;;:27;;21247:1;21221:27;;;21243:1;21221:27;21214:34;;;;;;;;;21184:171;21276:4;:12;;21284:4;21276:12;21272:83;;;21312:2;21309:5;;:2;:5;;;:13;;21321:1;21309:13;;21272:83;20011:1701;;;;21373:6;:13;;21383:3;21373:13;21369:343;;;21401:2;21397;:6;;;;21390:13;;;;;;21369:343;21429:6;:14;;21439:4;21429:14;21425:287;;;21472:4;:9;;21480:1;21472:9;21468:49;;;-1:-1:-1;;;21497:19:0;;;21483:34;;21468:49;21538:4;:12;;21546:4;21538:12;:28;;;;21554:4;:12;;21562:4;21554:12;21538:28;21534:170;;;21591:4;:12;;21599:4;21591:12;21587:26;;;21610:3;;;21587:26;21625:8;21639:45;21649:10;21646:13;;:18;21639:45;;21673:8;21668:3;21673:8;;;;;21668:3;21639:45;;;21692:1;-1:-1:-1;21685:8:0;;-1:-1:-1;;21685:8:0;21534:170;19412:3986;;;21737:4;21728:6;:13;;;21724:1674;;;21755:6;:14;;21765:4;21755:14;21751:776;;;21795:36;21811:2;21814:1;21811:4;21817:1;21810:8;21807:2;:11;21799:20;;:3;:20;;;;21823:4;21798:29;21829:1;21795:2;:36::i;:::-;21788:43;;;;;;21751:776;21850:6;:14;;21860:4;21850:14;21846:681;;;21890:39;21906:2;21909:1;21906:4;21912:1;21905:8;21902:2;:11;21894:20;;:3;:20;;;;21918:6;21893:31;21926:2;21890;:39::i;21846:681::-;21948:6;:14;;21958:4;21948:14;21944:583;;;-1:-1:-1;;;21995:17:0;22010:1;22007;22004:4;;22003:8;21995:17;;22036:32;;;22091:5;22086:10;;21995:17;;;;;22085:18;22078:25;;21944:583;22122:6;:14;;22132:4;22122:14;22118:409;;;22147:3;22140:10;;;;;;22118:409;22177:6;:14;;22187:4;22177:14;22173:354;;;22231:2;22234:1;22231:4;22237:1;22230:8;22227:2;:11;22219:20;;:3;:20;;;;22243:4;22218:29;22211:36;;;;;;22173:354;22266:6;:14;;22276:4;22266:14;22262:265;;;22320:2;22323:1;22320:4;22326:1;22319:8;22316:2;:11;22308:20;;:3;:20;;;;22332:6;22307:31;22300:38;;;;;;22262:265;22357:6;:14;;22367:4;22357:14;22353:174;;;-1:-1:-1;;;22404:20:0;22422:1;22419;22416:4;;22415:8;22412:2;:11;22404:20;;22448:35;;;22506:5;22501:10;;22404:20;;;;;22500:18;22493:25;;21724:1674;22543:6;:14;;22553:4;22543:14;22539:859;;;-1:-1:-1;;;22590:4:0;22586:26;22610:1;22607;22604:4;;22603:8;22600:2;:11;22586:26;;22654:21;;;22634:42;;;22692:10;;22587:7;;;22586:26;;22691:18;22684:25;;22539:859;22726:6;:14;;22736:4;22726:14;22722:676;;;-1:-1:-1;;;22773:6:0;22769:28;22795:1;22792;22789:4;;22788:8;22785:2;:11;22769:28;;22839:23;;;22819:44;;;22879:10;;22770:9;;;22769:28;;22878:18;22871:25;;22722:676;22913:6;:14;;22923:4;22913:14;22909:489;;;-1:-1:-1;;;22958:16:0;22972:1;22969;22966:4;;22965:8;22958:16;;22996:32;;;23050:5;23044:11;;22958:16;;;;;23043:19;23036:26;;22909:489;23079:6;:14;;23089:4;23079:14;23075:323;;;23116:2;23109:9;;;;;;23075:323;23135:6;:14;;23145:4;23135:14;23131:267;;;-1:-1:-1;;;23180:19:0;23197:1;23194;23191:4;;23190:8;23187:2;:11;23180:19;;23221:35;;;23278:5;23272:11;;23180:19;;;;;23271;23264:26;;23131:267;23307:6;:14;;23317:4;23307:14;23303:95;;;23332:3;23325:10;;;;;;23303:95;23358:6;:14;;23368:4;23358:14;23354:44;;;23383:2;23376:9;;;;;;23354:44;23404:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10855:455;10938:7;10953:18;;:::i;:::-;-1:-1:-1;11003:4:0;11037:2;11026:13;;;;11018:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11136:13;;;;;;;:28;;;11153:11;11136:28;11132:80;;;11202:3;11174:5;:15;;;11190:8;11174:25;;;;;;;;;:31;;;;:25;;;;;;:31;11132:80;11229:12;;;;;11218:23;;;;:8;;;:23;11277:1;11262:16;;;11247:31;;;11292:13;:11;:13::i;3420:4868::-;3463:7;3478:18;;:::i;:::-;-1:-1:-1;3563:15:0;;:18;;;;3528:4;3638:18;;;;3674;;;;3710;;;;;3528:4;;3543:17;;;;3638:18;3674;3739;;;3753:4;3739:18;3735:4396;;;3793:2;3810:4;3807:7;;:12;3803:98;;3887:4;3884:7;;3876:4;:16;3870:22;3803:98;3912:7;;;3908:105;;3936:10;;;;;3956:16;;;;;;;;3936:10;-1:-1:-1;3908:105:0;;;4002:2;3997:7;;3908:105;3735:4396;;;;4029:10;:18;;4043:4;4029:18;4025:4106;;;1458:10;4070:14;;4025:4106;;;4101:10;:18;;4115:4;4101:18;4097:4034;;;4165:1;4160:6;;4097:4034;;;4183:10;:18;;4197:4;4183:18;4179:3952;;;4246:4;4231:12;;;:19;4258:26;;;:14;;;:26;4299:13;:11;:13::i;:::-;4292:20;;;;;;;;;;;4179:3952;4329:10;:18;;4343:4;4329:18;4325:3806;;;4458:14;;;4454:1789;;;;;4549:22;;;1679:1;4549:22;4545:1698;;;4670:10;4683:27;4691:2;4696:10;4691:15;4708:1;4683:7;:27::i;:::-;4761:11;4792:6;;4812:17;;;;4831:20;;;;;4792:60;;;;;;;;;;;;;;;;;;;;4670:40;;-1:-1:-1;4761:11:0;;;;4792:6;;;;;:19;;:60;;;;;;;;;;;:6;:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4792:60:0;;;;;;;;;-1:-1:-1;4792:60:0;-1:-1:-1;4965:1:0;4957:10;;5045:1;5041:17;;;5106;;;5103:2;;;5136:5;5126:15;;5103:2;;5205:6;5201:2;5198:14;5195:2;;;5225;5215:12;;5195:2;5317:3;5312:1;5304:6;5300:14;5295:3;5291:24;5287:34;5280:41;;5403:3;5399:1;5387:9;5378:6;5375:1;5371:14;5367:30;5363:38;5359:48;5352:55;;5513:1;5509;5505;5493:9;5490:1;5486:17;5482:25;5478:33;5474:41;5626:1;5622;5618;5609:6;5597:9;5594:1;5590:17;5586:30;5582:38;5578:46;5574:54;5556:72;;5712:10;5708:15;5702:4;5698:26;5690:34;;5814:3;5806:4;5802:9;5797:3;5793:19;5790:28;5783:35;;;;5894:33;5903:2;5908:10;5903:15;5920:1;5923:3;5894:8;:33::i;:::-;5937:20;;;:38;;;;;;;;;-1:-1:-1;4545:1698:0;;-1:-1:-1;;4545:1698:0;;6023:18;;;1602:1;6023:18;6019:224;;;6172:2;6167:7;;6019:224;;;6204:10;6199:15;;1750:3;6224:10;;6019:224;4325:3806;;;6259:10;:18;;6273:4;6259:18;6255:1876;;;6392:15;;;1533:1;6392:15;;:34;;-1:-1:-1;6411:15:0;;;1566:1;6411:15;6392:34;:57;;;-1:-1:-1;6430:19:0;;;1639:1;6430:19;6392:57;6388:1172;;;6466:2;6461:7;;6388:1172;;;6530:23;;;1720:1;6530:23;6526:1034;;;6585:10;6598:27;6606:2;6611:10;6606:15;6623:1;6598:7;:27::i;:::-;6689:17;;;;6585:40;;-1:-1:-1;6819:1:0;6811:10;;6899:1;6895:17;6960:13;;;6957:2;;;6982:5;6976:11;;6957:2;7226:14;;;7060:1;7222:22;;;7218:32;;;;7129:26;7153:1;7052:10;;;7133:18;;;7129:26;7214:43;7048:20;;7308:12;7358:17;;;:23;7414:1;7391:20;;;:24;7056:2;-1:-1:-1;7056:2:0;6526:1034;;6255:1876;7576:10;:18;;7590:4;7576:18;7572:559;;;7650:2;:7;;7656:1;7650:7;7646:479;;;7711:14;;;;;:40;;-1:-1:-1;7729:22:0;;;1679:1;7729:22;7711:40;:62;;;-1:-1:-1;7755:18:0;;;1602:1;7755:18;7711:62;7707:312;;;7792:1;7787:6;;7707:312;;;7826:15;;;1533:1;7826:15;;:34;;-1:-1:-1;7845:15:0;;;1566:1;7845:15;7826:34;:61;;;-1:-1:-1;7864:23:0;;;1720:1;7864:23;7826:61;:84;;;-1:-1:-1;7891:19:0;;;1639:1;7891:19;7826:84;7822:197;;;7929:1;7924:6;;7822:197;;7646:479;8048:10;8043:15;;1782:4;8068:11;;7646:479;8137:15;;;;;:23;;;;:18;;;;:23;;;;8166:15;;:23;;;:18;;;;:23;-1:-1:-1;8207:12:0;;;;8196:23;;;:8;;;:23;8255:1;8240:16;8225:31;;;;;8270:13;:11;:13::i;:::-;8263:20;;;;;;;;;3420:4868;:::o;9359:1087::-;9449:7;9464:18;;:::i;:::-;-1:-1:-1;9514:4:0;9529:10;9557:4;9549:12;;;;9545:732;;;-1:-1:-1;9569:8:0;;;;9545:732;;;9600:4;:12;;9608:4;9600:12;9596:681;;;9614:13;;;:8;;;:13;9596:681;;;9650:4;:12;;9658:4;9650:12;9646:631;;;-1:-1:-1;9670:8:0;;;;9646:631;;;9701:4;:12;;9709:4;9701:12;9697:580;;;9715:13;;;:8;;;:13;9697:580;;;9751:4;:12;;9759:4;9751:12;9747:530;;;9861:7;9818:16;9801;;;9818;;;;9801:33;9866:2;9861:7;;;;;9843:8;;;:26;9877:22;:8;;;:22;9747:530;;;9916:4;:12;;9924:4;9916:12;9912:365;;;9978:10;9967;;;9978;;;9967:21;10020:2;10015:7;;;;;9997:8;;;:26;10031:22;:8;;;:22;9912:365;;;10070:4;:12;;10078:4;10070:12;10066:211;;;10133:2;10117:19;;10123:2;10117:19;;;;;;;;10099:38;;:8;;;:38;10163:19;;;;;;;;;;;;;;10145:38;;:8;;;:38;10066:211;;;10200:4;:12;;10208:4;10200:12;10196:81;;;10244:2;10241:5;;:2;:5;;;;;;;;10230:16;;;;:8;;;:16;10265:5;;;;;;;;;;;;10254:16;;:8;;;:16;10196:81;10287:13;;;;10283:65;;10338:3;10310:5;:15;;;10326:8;10310:25;;;;;;;;;:31;;;;:25;;;;;;:31;10283:65;10365:12;;;;;10354:23;;;;:8;;;:23;10413:1;10398:16;;;10383:31;;;10428:13;:11;:13::i;:::-;10421:20;9359:1087;-1:-1:-1;;;;;;;9359:1087:0:o;13171:1145::-;13254:14;13271:23;13283:10;13271:11;:23::i;:::-;13254:40;;13330:1;13324:4;13320:12;13317:2;;;13345:1;13342;13335:12;13317:2;13453;13616:15;;;13471:2;13461:13;;13449:10;13445:30;13442:1;13438:38;13581:17;;;13398:20;;13566:10;13555:22;;;13551:27;13541:38;13538:61;13833:4;13830:1;13826:12;13980:1;13965:273;13990:2;13987:1;13984:9;13965:273;;;14089:2;14077:15;;;14038:20;14112:12;;;14126:1;14108:20;14137:42;;;;14193:1;14188:42;;;;14101:129;;14137:42;14154:23;14169:7;14163:4;14154:23;:::i;:::-;14146:31;;14137:42;;14188;14205:23;14223:4;14214:7;14205:23;:::i;:::-;14197:31;;14101:129;-1:-1:-1;;14008:1:0;14001:9;13965:273;;;-1:-1:-1;;14252:4:0;14245:18;-1:-1:-1;;;;13309:1003:0:o;11314:460::-;11589:19;;;11612:5;11589:29;11582:3;:37;;;11660:14;;11695;;11689:21;;;11681:69;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11756:13;11314:460;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o"
 

op-challenger/challenger.go

 package op_challenger
 
 import (
+	"fmt"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
+	"github.com/ethereum-optimism/optimism/op-challenger/fault"
+	"github.com/ethereum-optimism/optimism/op-service/txmgr"
+	"github.com/ethereum-optimism/optimism/op-service/txmgr/metrics"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 )
 
 // Main is the programmatic entry-point for running op-challenger
 func Main(logger log.Logger, cfg *config.Config) error {
+	client, err := ethclient.Dial(cfg.L1EthRpc)
+	if err != nil {
+		return fmt.Errorf("failed to dial L1: %w", err)
+	}
+
+	txMgr, err := txmgr.NewSimpleTxManager("challenger", logger, &metrics.NoopTxMetrics{}, cfg.TxMgrConfig)
+	if err != nil {
+		return fmt.Errorf("failed to create the transaction manager: %w", err)
+	}
+
+	contract, err := bindings.NewFaultDisputeGameCaller(cfg.GameAddress, client)
+	if err != nil {
+		return fmt.Errorf("failed to bind the fault dispute game contract: %w", err)
+	}
+
+	loader := fault.NewLoader(logger, contract)
+	responder, err := fault.NewFaultResponder(logger, txMgr, cfg.GameAddress)
+	if err != nil {
+		return fmt.Errorf("failed to create the responder: %w", err)
+	}
+	gameDepth := 4
+	trace := fault.NewAlphabetProvider(cfg.AlphabetTrace, uint64(gameDepth))
+
+	agent := fault.NewAgent(loader, gameDepth, trace, responder, logger)
+
 	logger.Info("Fault game started")
-	return nil
+
+	for {
+		logger.Info("Performing action")
+		_ = agent.Act()
+		time.Sleep(300 * time.Millisecond)
+	}
 }

op-challenger/charlie

+#!/bin/bash
+set -euo pipefail
+
+DIR=$(cd $(dirname "${BASH_SOURCE[0]}") && pwd)
+cd "$DIR"
+
+DISPUTE_GAME_PROXY="0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e"
+
+CHARLIE_ADDRESS="0xF45B7537828CB2fffBC69996B054c2Aaf36DC778"
+CHARLIE_KEY="74feb147d72bfae943e6b4e483410933d9e447d5dc47d52432dcc2c1454dabb7"
+
+MALLORY_ADDRESS="0x4641c704a6c743f73ee1f36C7568Fbf4b80681e4"
+MALLORY_KEY="28d7045146193f5f4eeb151c4843544b1b0d30a7ac1680c845a416fac65a7715"
+
+FAULT_GAME_ADDRESS="0x8daf17a20c9dba35f005b6324f493785d239719d"
+
+./bin/op-challenger --l1-eth-rpc http://localhost:8545 --alphabet "abcdefgh" --game-address $FAULT_GAME_ADDRESS --private-key $CHARLIE_KEY --num-confirmations 1 

op-challenger/fault/abi_test.go

+package fault
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/stretchr/testify/require"
+)
+
+// setupFaultDisputeGame deploys the FaultDisputeGame contract to a simulated backend
+func setupFaultDisputeGame() (common.Address, *bind.TransactOpts, *backends.SimulatedBackend, *bindings.FaultDisputeGame, error) {
+	privateKey, err := crypto.GenerateKey()
+	from := crypto.PubkeyToAddress(privateKey.PublicKey)
+	if err != nil {
+		return common.Address{}, nil, nil, nil, err
+	}
+	opts, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337))
+	if err != nil {
+		return common.Address{}, nil, nil, nil, err
+	}
+	backend := backends.NewSimulatedBackend(core.GenesisAlloc{from: {Balance: big.NewInt(params.Ether)}}, 50_000_000)
+	_, _, contract, err := bindings.DeployFaultDisputeGame(
+		opts,
+		backend,
+		[32]byte{0x01},
+		big.NewInt(15),
+		common.Address{0xdd},
+	)
+	if err != nil {
+		return common.Address{}, nil, nil, nil, err
+	}
+	return from, opts, backend, contract, nil
+}
+
+// TestBuildFaultDefendData ensures that the manual ABI packing is the same as going through the bound contract.
+func TestBuildFaultDefendData(t *testing.T) {
+	_, opts, _, contract, err := setupFaultDisputeGame()
+	require.NoError(t, err)
+
+	responder, _ := newTestFaultResponder(t, false)
+
+	data, err := responder.buildFaultDefendData(1, [32]byte{0x02, 0x03})
+	require.NoError(t, err)
+
+	opts.GasLimit = 100_000
+	tx, err := contract.Defend(opts, big.NewInt(1), [32]byte{0x02, 0x03})
+	require.NoError(t, err)
+
+	require.Equal(t, data, tx.Data())
+}
+
+// TestBuildFaultAttackData ensures that the manual ABI packing is the same as going through the bound contract.
+func TestBuildFaultAttackData(t *testing.T) {
+	_, opts, _, contract, err := setupFaultDisputeGame()
+	require.NoError(t, err)
+
+	responder, _ := newTestFaultResponder(t, false)
+
+	data, err := responder.buildFaultAttackData(1, [32]byte{0x02, 0x03})
+	require.NoError(t, err)
+
+	opts.GasLimit = 100_000
+	tx, err := contract.Attack(opts, big.NewInt(1), [32]byte{0x02, 0x03})
+	require.NoError(t, err)
+
+	require.Equal(t, data, tx.Data())
+}
+
+// TestBuildFaultStepData ensures that the manual ABI packing is the same as going through the bound contract.
+func TestBuildFaultStepData(t *testing.T) {
+	_, opts, _, contract, err := setupFaultDisputeGame()
+	require.NoError(t, err)
+
+	responder, _ := newTestFaultResponder(t, false)
+
+	data, err := responder.buildStepTxData(StepCallData{
+		ClaimIndex: 2,
+		IsAttack:   false,
+		StateData:  []byte{0x01},
+		Proof:      []byte{0x02},
+	})
+	require.NoError(t, err)
+
+	opts.GasLimit = 100_000
+	tx, err := contract.Step(opts, big.NewInt(2), false, []byte{0x01}, []byte{0x02})
+	require.NoError(t, err)
+
+	require.Equal(t, data, tx.Data())
+}

op-challenger/fault/agent.go

@@ -2,70 +2,117 @@ package fault
 
 import (
 	"context"
-	"sync"
+	"errors"
+	"fmt"
 
 	"github.com/ethereum/go-ethereum/log"
 )
 
 type Agent struct {
-	mu        sync.Mutex
-	game      Game
 	solver    *Solver
 	trace     TraceProvider
+	loader    Loader
 	responder Responder
 	maxDepth  int
 	log       log.Logger
 }
 
-func NewAgent(game Game, maxDepth int, trace TraceProvider, responder Responder, log log.Logger) Agent {
+func NewAgent(loader Loader, maxDepth int, trace TraceProvider, responder Responder, log log.Logger) Agent {
 	return Agent{
-		game:      game,
 		solver:    NewSolver(maxDepth, trace),
 		trace:     trace,
+		loader:    loader,
 		responder: responder,
 		maxDepth:  maxDepth,
 		log:       log,
 	}
 }
 
-// AddClaim stores a claim in the local state.
-// This function shares a lock with PerformActions.
-func (a *Agent) AddClaim(claim Claim) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.game.Put(claim)
+// Act iterates the game & performs all of the next actions.
+func (a *Agent) Act() error {
+	game, err := a.newGameFromContracts(context.Background())
+	if err != nil {
+		a.log.Error("Failed to create new game", "err", err)
+		return err
+	}
+	// Create counter claims
+	for _, claim := range game.Claims() {
+		if err := a.move(claim, game); err != nil {
+			log.Error("Failed to move", "err", err)
+		}
+	}
+	// Step on all leaf claims
+	for _, claim := range game.Claims() {
+		if err := a.step(claim, game); err != nil {
+			log.Error("Failed to step", "err", err)
+		}
+	}
+	return nil
 }
 
-// PerformActions iterates the game & performs all of the next actions.
-// Note: PerformActions & AddClaim share a lock so the responder cannot
-// call AddClaim on the same thread.
-func (a *Agent) PerformActions() {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, claim := range a.game.Claims() {
-		_ = a.move(claim)
+// newGameFromContracts initializes a new game state from the state in the contract
+func (a *Agent) newGameFromContracts(ctx context.Context) (Game, error) {
+	claims, err := a.loader.FetchClaims(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch claims: %w", err)
+	}
+	if len(claims) == 0 {
+		return nil, errors.New("no claims")
+	}
+	game := NewGameState(claims[0], uint64(a.maxDepth))
+	if err := game.PutAll(claims[1:]); err != nil {
+		return nil, fmt.Errorf("failed to load claims into the local state: %w", err)
 	}
+	return game, nil
 }
 
-// move determines & executes the next move given a claim pair
-func (a *Agent) move(claim Claim) error {
+// move determines & executes the next move given a claim
+func (a *Agent) move(claim Claim, game Game) error {
 	nextMove, err := a.solver.NextMove(claim)
 	if err != nil {
 		a.log.Warn("Failed to execute the next move", "err", err)
 		return err
 	}
 	if nextMove == nil {
-		a.log.Info("No next move")
+		a.log.Debug("No next move")
 		return nil
 	}
 	move := *nextMove
-	log := a.log.New("is_defend", move.DefendsParent(), "depth", move.Depth(), "index_at_depth", move.IndexAtDepth(), "value", move.Value,
-		"letter", string(move.Value[31:]), "trace_index", move.Value[30],
-		"parent_letter", string(claim.Value[31:]), "parent_trace_index", claim.Value[30])
-	if a.game.IsDuplicate(move) {
+	log := a.log.New("is_defend", move.DefendsParent(), "depth", move.Depth(), "index_at_depth", move.IndexAtDepth(),
+		"value", move.Value, "trace_index", move.TraceIndex(a.maxDepth),
+		"parent_value", claim.Value, "parent_trace_index", claim.TraceIndex(a.maxDepth))
+	if game.IsDuplicate(move) {
 		log.Debug("Duplicate move")
 		return nil
 	}
 	log.Info("Performing move")
 	return a.responder.Respond(context.TODO(), move)
 }
+
+// step determines & executes the next step against a leaf claim through the responder
+func (a *Agent) step(claim Claim, game Game) error {
+	if claim.Depth() != a.maxDepth {
+		return nil
+	}
+	a.log.Info("Attempting step", "claim_depth", claim.Depth(), "maxDepth", a.maxDepth)
+	step, err := a.solver.AttemptStep(claim)
+	if err != nil {
+		a.log.Warn("Failed to get a step", "err", err)
+		return err
+	}
+	stateData, err := a.trace.GetPreimage(step.PreStateTraceIndex)
+	if err != nil {
+		a.log.Warn("Failed to get a state data", "err", err)
+		return err
+	}
+
+	a.log.Info("Performing step",
+		"depth", step.LeafClaim.Depth(), "index_at_depth", step.LeafClaim.IndexAtDepth(), "value", step.LeafClaim.Value,
+		"is_attack", step.IsAttack, "prestate_trace_index", step.PreStateTraceIndex)
+	callData := StepCallData{
+		ClaimIndex: uint64(step.LeafClaim.ContractIndex),
+		IsAttack:   step.IsAttack,
+		StateData:  stateData,
+	}
+	return a.responder.Step(context.TODO(), callData)
+}

op-challenger/fault/alphabet_provider.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 )
 
 // AlphabetProvider is a [TraceProvider] that provides claims for specific
@@ -32,7 +33,7 @@ func (ap *AlphabetProvider) GetPreimage(i uint64) ([]byte, error) {
 	if i >= uint64(len(ap.state)) {
 		return ap.GetPreimage(uint64(len(ap.state)) - 1)
 	}
-	return buildAlphabetClaimBytes(i, ap.state[i]), nil
+	return BuildAlphabetPreimage(i, ap.state[i]), nil
 }
 
 // Get returns the claim value at the given index in the trace.
@@ -41,17 +42,25 @@ func (ap *AlphabetProvider) Get(i uint64) (common.Hash, error) {
 	if err != nil {
 		return common.Hash{}, err
 	}
-	return common.BytesToHash(claimBytes), nil
+	return crypto.Keccak256Hash(claimBytes), nil
 }
 
-// buildAlphabetClaimBytes constructs the claim bytes for the index and state item.
-func buildAlphabetClaimBytes(i uint64, letter string) []byte {
-	return append(IndexToBytes(i), []byte(letter)...)
+// BuildAlphabetPreimage constructs the claim bytes for the index and state item.
+func BuildAlphabetPreimage(i uint64, letter string) []byte {
+	return append(IndexToBytes(i), LetterToBytes(letter)...)
 }
 
 // IndexToBytes converts an index to a byte slice big endian
 func IndexToBytes(i uint64) []byte {
 	big := new(big.Int)
 	big.SetUint64(i)
-	return big.Bytes()
+	out := make([]byte, 32)
+	return big.FillBytes(out)
+}
+
+// LetterToBytes converts a letter to a 32 byte array
+func LetterToBytes(letter string) []byte {
+	out := make([]byte, 32)
+	out[31] = byte(letter[0])
+	return out
 }

op-challenger/fault/alphabet_provider_test.go

@@ -20,15 +20,15 @@ func TestAlphabetProvider_Get_ClaimsByTraceIndex(t *testing.T) {
 	}{
 		{
 			7,
-			common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000768"),
+			alphabetClaim(7, "h"),
 		},
 		{
 			3,
-			common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000364"),
+			alphabetClaim(3, "d"),
 		},
 		{
 			5,
-			common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000566"),
+			alphabetClaim(5, "f"),
 		},
 	}
 
@@ -54,7 +54,7 @@ func FuzzIndexToBytes(f *testing.F) {
 // returns the correct pre-image for a index.
 func TestGetPreimage_Succeeds(t *testing.T) {
 	ap := NewAlphabetProvider("abc", 2)
-	expected := append(IndexToBytes(uint64(0)), []byte("a")...)
+	expected := BuildAlphabetPreimage(0, "a'")
 	retrieved, err := ap.GetPreimage(uint64(0))
 	require.NoError(t, err)
 	require.Equal(t, expected, retrieved)
@@ -73,8 +73,7 @@ func TestGet_Succeeds(t *testing.T) {
 	ap := NewAlphabetProvider("abc", 2)
 	claim, err := ap.Get(0)
 	require.NoError(t, err)
-	concatenated := append(IndexToBytes(0), []byte("a")...)
-	expected := common.BytesToHash(concatenated)
+	expected := alphabetClaim(0, "a")
 	require.Equal(t, expected, claim)
 }
 
@@ -92,7 +91,6 @@ func TestGet_Extends(t *testing.T) {
 	ap := NewAlphabetProvider("abc", 2)
 	claim, err := ap.Get(3)
 	require.NoError(t, err)
-	concatenated := append(IndexToBytes(2), []byte("c")...)
-	expected := common.BytesToHash(concatenated)
+	expected := alphabetClaim(2, "c")
 	require.Equal(t, expected, claim)
 }

op-challenger/fault/game.go

@@ -36,9 +36,8 @@ type Game interface {
 }
 
 type extendedClaim struct {
-	self          Claim
-	contractIndex int
-	children      []ClaimData
+	self     Claim
+	children []ClaimData
 }
 
 // gameState is a struct that represents the state of a dispute game.
@@ -54,9 +53,8 @@ type gameState struct {
 func NewGameState(root Claim, depth uint64) *gameState {
 	claims := make(map[ClaimData]*extendedClaim)
 	claims[root.ClaimData] = &extendedClaim{
-		self:          root,
-		contractIndex: 0,
-		children:      make([]ClaimData, 0),
+		self:     root,
+		children: make([]ClaimData, 0),
 	}
 	return &gameState{
 		root:   root.ClaimData,
@@ -87,9 +85,8 @@ func (g *gameState) Put(claim Claim) error {
 		parent.children = append(parent.children, claim.ClaimData)
 	}
 	g.claims[claim.ClaimData] = &extendedClaim{
-		self:          claim,
-		contractIndex: claim.ContractIndex,
-		children:      make([]ClaimData, 0),
+		self:     claim,
+		children: make([]ClaimData, 0),
 	}
 	return nil
 }

op-challenger/fault/loader.go

@@ -28,18 +28,14 @@ type Loader interface {
 
 // loader pulls in fault dispute game claim data periodically and over subscriptions.
 type loader struct {
-	log log.Logger
-
-	state Game
-
+	log          log.Logger
 	claimFetcher ClaimFetcher
 }
 
 // NewLoader creates a new [loader].
-func NewLoader(log log.Logger, state Game, claimFetcher ClaimFetcher) *loader {
+func NewLoader(log log.Logger, claimFetcher ClaimFetcher) *loader {
 	return &loader{
 		log:          log,
-		state:        state,
 		claimFetcher: claimFetcher,
 	}
 }
@@ -60,6 +56,8 @@ func (l *loader) fetchClaim(ctx context.Context, arrIndex uint64) (Claim, error)
 			Value:    fetchedClaim.Claim,
 			Position: NewPositionFromGIndex(fetchedClaim.Position.Uint64()),
 		},
+		ContractIndex:       int(arrIndex),
+		ParentContractIndex: int(fetchedClaim.ParentIndex),
 	}
 
 	if !claim.IsRootPosition() {

op-challenger/fault/loader_test.go

@@ -15,46 +15,8 @@ import (
 var (
 	mockClaimDataError = fmt.Errorf("claim data errored")
 	mockClaimLenError  = fmt.Errorf("claim len errored")
-	mockPutError       = fmt.Errorf("put errored")
 )
 
-type mockGameState struct {
-	putCalled int
-	putErrors bool
-}
-
-func (m *mockGameState) Put(claim Claim) error {
-	m.putCalled++
-	if m.putErrors {
-		return mockPutError
-	}
-	return nil
-}
-
-func (m *mockGameState) PutAll(claims []Claim) error {
-	m.putCalled += len(claims)
-	if m.putErrors {
-		return mockPutError
-	}
-	return nil
-}
-
-func (m *mockGameState) Claims() []Claim {
-	return []Claim{}
-}
-
-func (m *mockGameState) IsDuplicate(claim Claim) bool {
-	return false
-}
-
-func (m *mockGameState) PreStateClaim(claim Claim) (Claim, error) {
-	panic("unimplemented")
-}
-
-func (m *mockGameState) PostStateClaim(claim Claim) (Claim, error) {
-	panic("unimplemented")
-}
-
 type mockClaimFetcher struct {
 	claimDataError bool
 	claimLenError  bool
@@ -126,7 +88,7 @@ func TestLoader_FetchClaims_Succeeds(t *testing.T) {
 	log := testlog.Logger(t, log.LvlError)
 	mockClaimFetcher := newMockClaimFetcher()
 	expectedClaims := mockClaimFetcher.returnClaims
-	loader := NewLoader(log, &mockGameState{}, mockClaimFetcher)
+	loader := NewLoader(log, mockClaimFetcher)
 	claims, err := loader.FetchClaims(context.Background())
 	require.NoError(t, err)
 	require.ElementsMatch(t, []Claim{
@@ -139,6 +101,7 @@ func TestLoader_FetchClaims_Succeeds(t *testing.T) {
 				Value:    expectedClaims[0].Claim,
 				Position: NewPositionFromGIndex(expectedClaims[0].Position.Uint64()),
 			},
+			ContractIndex: 0,
 		},
 		{
 			ClaimData: ClaimData{
@@ -149,6 +112,7 @@ func TestLoader_FetchClaims_Succeeds(t *testing.T) {
 				Value:    expectedClaims[0].Claim,
 				Position: NewPositionFromGIndex(expectedClaims[1].Position.Uint64()),
 			},
+			ContractIndex: 1,
 		},
 		{
 			ClaimData: ClaimData{
@@ -159,6 +123,7 @@ func TestLoader_FetchClaims_Succeeds(t *testing.T) {
 				Value:    expectedClaims[0].Claim,
 				Position: NewPositionFromGIndex(expectedClaims[2].Position.Uint64()),
 			},
+			ContractIndex: 2,
 		},
 	}, claims)
 }
@@ -169,7 +134,7 @@ func TestLoader_FetchClaims_ClaimDataErrors(t *testing.T) {
 	log := testlog.Logger(t, log.LvlError)
 	mockClaimFetcher := newMockClaimFetcher()
 	mockClaimFetcher.claimDataError = true
-	loader := NewLoader(log, &mockGameState{}, mockClaimFetcher)
+	loader := NewLoader(log, mockClaimFetcher)
 	claims, err := loader.FetchClaims(context.Background())
 	require.ErrorIs(t, err, mockClaimDataError)
 	require.Empty(t, claims)
@@ -181,7 +146,7 @@ func TestLoader_FetchClaims_ClaimLenErrors(t *testing.T) {
 	log := testlog.Logger(t, log.LvlError)
 	mockClaimFetcher := newMockClaimFetcher()
 	mockClaimFetcher.claimLenError = true
-	loader := NewLoader(log, &mockGameState{}, mockClaimFetcher)
+	loader := NewLoader(log, mockClaimFetcher)
 	claims, err := loader.FetchClaims(context.Background())
 	require.ErrorIs(t, err, mockClaimLenError)
 	require.Empty(t, claims)

op-challenger/fault/orchestrator.go

@@ -2,74 +2,74 @@ package fault
 
 import (
 	"context"
-	"os"
-	"time"
 
 	"github.com/ethereum/go-ethereum/log"
 )
 
 type Orchestrator struct {
-	agents    []Agent
-	outputChs []chan Claim
-	responses chan Claim
+	agents []Agent
+	claims []Claim
+	steps  []StepCallData
+
+	// tracking when to exit
+	claimLen, stepLen, step int
 }
 
 func NewOrchestrator(maxDepth uint64, traces []TraceProvider, names []string, root Claim) Orchestrator {
 	o := Orchestrator{
-		responses: make(chan Claim, 100),
-		outputChs: make([]chan Claim, len(traces)),
-		agents:    make([]Agent, len(traces)),
+		agents: make([]Agent, len(traces)),
+		claims: []Claim{root},
+		steps:  make([]StepCallData, 0),
 	}
 	log.Info("Starting game", "root_letter", string(root.Value[31:]))
 	for i, trace := range traces {
-		game := NewGameState(root, maxDepth)
-		o.agents[i] = NewAgent(game, int(maxDepth), trace, &o, log.New("role", names[i]))
-		o.outputChs[i] = make(chan Claim)
+		o.agents[i] = NewAgent(&o, int(maxDepth), trace, &o, log.New("role", names[i]))
 	}
 	return o
 }
 
 func (o *Orchestrator) Respond(_ context.Context, response Claim) error {
-	o.responses <- response
+	response.ContractIndex = len(o.claims)
+	o.claims = append(o.claims, response)
 	return nil
 }
 
-func (o *Orchestrator) Step(ctx context.Context, stepData StepCallData) error {
+func (o *Orchestrator) Step(_ context.Context, stepData StepCallData) error {
+	log.Info("Step recorded", "step", stepData)
+	o.steps = append(o.steps, stepData)
 	return nil
 }
 
-func (o *Orchestrator) Start() {
-	for i := 0; i < len(o.agents); i++ {
-		go runAgent(&o.agents[i], o.outputChs[i])
-	}
-	o.responderThread()
+func (o *Orchestrator) FetchClaims(ctx context.Context) ([]Claim, error) {
+	c := make([]Claim, len(o.claims))
+	copy(c, o.claims)
+	return c, nil
 }
 
-func runAgent(agent *Agent, claimCh <-chan Claim) {
+func (o *Orchestrator) Start() {
 	for {
-		agent.PerformActions()
-		// Note: Should drain the channel here
-		claim := <-claimCh
-		_ = agent.AddClaim(claim)
-
+		for _, a := range o.agents {
+			_ = a.Act()
+		}
+		if o.shouldExit() {
+			log.Info("exiting")
+			return
+		}
 	}
 }
 
-func (o *Orchestrator) responderThread() {
-	timer := time.NewTimer(200 * time.Millisecond)
-	defer timer.Stop()
-	for {
-		select {
-		case resp := <-o.responses:
-			timer.Reset(200 * time.Millisecond)
-			for _, ch := range o.outputChs {
-				// Copy it. Should be immutable, but be sure.
-				resp := resp
-				ch <- resp
-			}
-		case <-timer.C:
-			os.Exit(0)
-		}
+func (o *Orchestrator) shouldExit() bool {
+	cl := o.claimLen
+	sl := o.stepLen
+
+	o.claimLen = len(o.claims)
+	o.stepLen = len(o.steps)
 
+	noProgress := o.claimLen == cl && o.stepLen == sl
+	if noProgress {
+		o.step = o.step + 1
+	} else {
+		o.step = 0
 	}
+	return noProgress && o.step == 1
 }

op-challenger/fault/responder.go

@@ -104,7 +104,6 @@ func (r *faultResponder) sendTxAndWait(ctx context.Context, txData []byte) error
 func (r *faultResponder) buildStepTxData(stepData StepCallData) ([]byte, error) {
 	return r.fdgAbi.Pack(
 		"step",
-		big.NewInt(int64(stepData.StateIndex)),
 		big.NewInt(int64(stepData.ClaimIndex)),
 		stepData.IsAttack,
 		stepData.StateData,

op-challenger/fault/solver.go

@@ -9,7 +9,6 @@ import (
 // Solver uses a [TraceProvider] to determine the moves to make in a dispute game.
 type Solver struct {
 	TraceProvider
-
 	gameDepth int
 }
 
@@ -31,14 +30,14 @@ func (s *Solver) NextMove(claim Claim) (*Claim, error) {
 }
 
 type StepData struct {
-	LeafClaim  Claim
-	StateClaim Claim
-	IsAttack   bool
+	LeafClaim          Claim
+	IsAttack           bool
+	PreStateTraceIndex uint64
 }
 
 // AttemptStep determines what step should occur for a given leaf claim.
 // An error will be returned if the claim is not at the max depth.
-func (s *Solver) AttemptStep(claim Claim, state Game) (StepData, error) {
+func (s *Solver) AttemptStep(claim Claim) (StepData, error) {
 	if claim.Depth() != s.gameDepth {
 		return StepData{}, errors.New("cannot step on non-leaf claims")
 	}
@@ -46,20 +45,15 @@ func (s *Solver) AttemptStep(claim Claim, state Game) (StepData, error) {
 	if err != nil {
 		return StepData{}, err
 	}
-	var selectorFn func(Claim) (Claim, error)
-	if claimCorrect {
-		selectorFn = state.PostStateClaim
-	} else {
-		selectorFn = state.PreStateClaim
-	}
-	stateClaim, err := selectorFn(claim)
-	if err != nil {
-		return StepData{}, err
+	index := claim.TraceIndex(s.gameDepth)
+	// TODO(CLI-4198): Handle case where we dispute trace index 0
+	if !claimCorrect {
+		index -= 1
 	}
 	return StepData{
-		LeafClaim:  claim,
-		StateClaim: stateClaim,
-		IsAttack:   claimCorrect,
+		LeafClaim:          claim,
+		IsAttack:           !claimCorrect,
+		PreStateTraceIndex: index,
 	}, nil
 }
 
@@ -117,8 +111,9 @@ func (s *Solver) attack(claim Claim) (*Claim, error) {
 		return nil, err
 	}
 	return &Claim{
-		ClaimData: ClaimData{Value: value, Position: position},
-		Parent:    claim.ClaimData,
+		ClaimData:           ClaimData{Value: value, Position: position},
+		Parent:              claim.ClaimData,
+		ParentContractIndex: claim.ContractIndex,
 	}, nil
 }
 
@@ -130,8 +125,9 @@ func (s *Solver) defend(claim Claim) (*Claim, error) {
 		return nil, err
 	}
 	return &Claim{
-		ClaimData: ClaimData{Value: value, Position: position},
-		Parent:    claim.ClaimData,
+		ClaimData:           ClaimData{Value: value, Position: position},
+		Parent:              claim.ClaimData,
+		ParentContractIndex: claim.ContractIndex,
 	}, nil
 }
 

op-challenger/fault/solver_test.go

@@ -4,9 +4,14 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/stretchr/testify/require"
 )
 
+func alphabetClaim(index uint64, letter string) common.Hash {
+	return crypto.Keccak256Hash(BuildAlphabetPreimage(index, letter))
+}
+
 // TestSolver_NextMove_Opponent tests the [Solver] NextMove function
 // with an [fault.AlphabetProvider] as the [TraceProvider].
 func TestSolver_NextMove_Opponent(t *testing.T) {
@@ -18,55 +23,51 @@ func TestSolver_NextMove_Opponent(t *testing.T) {
 	// The following claims are created using the state: "abcdexyz".
 	// The responses are the responses we expect from the solver.
 	indices := []struct {
-		traceIndex int
-		claim      Claim
-		response   ClaimData
+		claim    Claim
+		response ClaimData
 	}{
 		{
-			7,
 			Claim{
 				ClaimData: ClaimData{
-					Value:    common.HexToHash("0x000000000000000000000000000000000000000000000000000000000000077a"),
+					Value:    alphabetClaim(7, "z"),
 					Position: NewPosition(0, 0),
 				},
 				// Root claim has no parent
 			},
 			ClaimData{
-				Value:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000364"),
+				Value:    alphabetClaim(3, "d"),
 				Position: NewPosition(1, 0),
 			},
 		},
 		{
-			3,
 			Claim{
 				ClaimData: ClaimData{
-					Value:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000364"),
+					Value:    alphabetClaim(3, "d"),
 					Position: NewPosition(1, 0),
 				},
 				Parent: ClaimData{
-					Value:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000768"),
+					Value:    alphabetClaim(7, "h"),
 					Position: NewPosition(0, 0),
 				},
 			},
 			ClaimData{
-				Value:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000566"),
+				Value:    alphabetClaim(5, "f"),
 				Position: NewPosition(2, 2),
 			},
 		},
 		{
-			5,
 			Claim{
 				ClaimData: ClaimData{
-					Value:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000578"),
+					Value:    alphabetClaim(5, "x"),
 					Position: NewPosition(2, 2),
 				},
 				Parent: ClaimData{
-					Value:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000768"),
+					Value:    alphabetClaim(7, "h"),
 					Position: NewPosition(1, 1),
 				},
 			},
 			ClaimData{
-				Value:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000465"),
+				Value:    alphabetClaim(4, "e"),
 				Position: NewPosition(3, 4),
 			},
 		},
@@ -89,12 +90,11 @@ func TestAttemptStep(t *testing.T) {
 	require.NoError(t, g.Put(middle))
 	require.NoError(t, g.Put(bottom))
 
-	step, err := solver.AttemptStep(bottom, g)
+	step, err := solver.AttemptStep(bottom)
 	require.NoError(t, err)
 	require.Equal(t, bottom, step.LeafClaim)
-	require.Equal(t, middle, step.StateClaim)
 	require.True(t, step.IsAttack)
 
-	_, err = solver.AttemptStep(middle, g)
+	_, err = solver.AttemptStep(middle)
 	require.Error(t, err)
 }

op-challenger/fault/types.go

@@ -14,7 +14,6 @@ var (
 
 // StepCallData encapsulates the data needed to perform a step.
 type StepCallData struct {
-	StateIndex uint64
 	ClaimIndex uint64
 	IsAttack   bool
 	StateData  []byte

op-challenger/init_game

+#!/bin/bash
+set -euo pipefail
+
+DIR=$(cd $(dirname "${BASH_SOURCE[0]}") && pwd)
+cd "$DIR"
+
+# build the challenger to keep it up to date
+make
+
+cd ..
+
+make devnet-clean
+make devnet-up-deploy
+
+DEVNET_SPONSOR="ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+DISPUTE_GAME_PROXY="0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e"
+
+CHARLIE_ADDRESS="0xF45B7537828CB2fffBC69996B054c2Aaf36DC778"
+CHARLIE_KEY="74feb147d72bfae943e6b4e483410933d9e447d5dc47d52432dcc2c1454dabb7"
+
+MALLORY_ADDRESS="0x4641c704a6c743f73ee1f36C7568Fbf4b80681e4"
+MALLORY_KEY="28d7045146193f5f4eeb151c4843544b1b0d30a7ac1680c845a416fac65a7715"
+
+
+
+echo "----------------------------------------------------------------"
+echo " - Fetching balance of the sponsor"
+echo " - Balance: $(cast balance 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)"
+echo "----------------------------------------------------------------"
+
+
+echo "Funding Charlie"
+cast send $CHARLIE_ADDRESS --value 5ether --private-key $DEVNET_SPONSOR
+
+echo "Funding Mallory"
+cast send $MALLORY_ADDRESS --value 5ether --private-key $DEVNET_SPONSOR
+
+
+# Fault game type = 0
+GAME_TYPE=0
+# Root claim commits to the entire trace.
+# Alphabet game claim construction: keccak256(abi.encode(trace_index, trace[trace_index]))
+ROOT_CLAIM=$(cast keccak $(cast abi-encode "f(uint256,uint256)" 15 122))
+# Extra data is a dynamic `bytes` type that contains the L2 Block Number of the output proposal that the root claim disagrees with
+# Doesn't matter right now since we're not deleting outputs, so just set it to 1
+EXTRA_DATA=$(cast to-bytes32 1)
+
+
+
+echo "Initializing the game"
+cast call --private-key $MALLORY_KEY $DISPUTE_GAME_PROXY "create(uint8,bytes32,bytes)" $GAME_TYPE $ROOT_CLAIM $EXTRA_DATA
+cast send --private-key $MALLORY_KEY $DISPUTE_GAME_PROXY "create(uint8,bytes32,bytes)" $GAME_TYPE $ROOT_CLAIM $EXTRA_DATA

op-challenger/mallory

+#!/bin/bash
+set -euo pipefail
+
+
+DIR=$(cd $(dirname "${BASH_SOURCE[0]}") && pwd)
+cd "$DIR"
+
+DISPUTE_GAME_PROXY="0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e"
+
+CHARLIE_ADDRESS="0xF45B7537828CB2fffBC69996B054c2Aaf36DC778"
+CHARLIE_KEY="74feb147d72bfae943e6b4e483410933d9e447d5dc47d52432dcc2c1454dabb7"
+
+MALLORY_ADDRESS="0x4641c704a6c743f73ee1f36C7568Fbf4b80681e4"
+MALLORY_KEY="28d7045146193f5f4eeb151c4843544b1b0d30a7ac1680c845a416fac65a7715"
+
+FAULT_GAME_ADDRESS="0x8daf17a20c9dba35f005b6324f493785d239719d"
+
+./bin/op-challenger --l1-eth-rpc http://localhost:8545 --alphabet "abcdexyz" --game-address $FAULT_GAME_ADDRESS --private-key $MALLORY_KEY --num-confirmations 1

op-challenger/visualize

+#!/bin/bash
+
+set -euo pipefail
+
+DISPUTE_GAME_PROXY="0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e"
+
+FAULT_GAME_ADDRESS="0x8daf17a20c9dba35f005b6324f493785d239719d"
+
+dir=$(cd $(dirname "${BASH_SOURCE[0]}") && pwd)
+cd "$dir"
+cd ../packages/contracts-bedrock
+
+forge script scripts/FaultDisputeGameViz.s.sol --sig "remote(address)" $FAULT_GAME_ADDRESS --fork-url http://localhost:8545
+mv dispute_game.svg "$dir"

op-node/p2p/app_params.go

@@ -38,11 +38,11 @@ func LightApplicationScoreParams(cfg *rollup.Config) ApplicationScoreParams {
 		ValidResponseWeight: 0.5,
 		ValidResponseDecay:  ScoreDecay(tenEpochs, slot),
 
-		// Takes 20 error responses to reach the default ban threshold of -100
-		// But at most we track 10. These errors include not supporting p2p sync
-		// so we don't (yet) want to ban a peer based on this measure alone.
-		ErrorResponseCap:    10,
-		ErrorResponseWeight: -5,
+		// Takes 10 error responses to reach the default gossip threshold of -10
+		// But at most we track 9. These errors include not supporting p2p sync
+		// so we don't (yet) want to ignore gossip from a peer based on this measure alone.
+		ErrorResponseCap:    9,
+		ErrorResponseWeight: -1,
 		ErrorResponseDecay:  ScoreDecay(tenEpochs, slot),
 
 		// Takes 5 rejected payloads to reach the default ban threshold of -100

op-node/rollup/derive/pipeline.go

@@ -15,7 +15,7 @@ type Metrics interface {
 	RecordL1Ref(name string, ref eth.L1BlockRef)
 	RecordL2Ref(name string, ref eth.L2BlockRef)
 	RecordUnsafePayloadsBuffer(length uint64, memSize uint64, next eth.BlockID)
-	RecordChannelInputBytes(inputCompresedBytes int)
+	RecordChannelInputBytes(inputCompressedBytes int)
 }
 
 type L1Fetcher interface {

op-node/rollup/driver/driver.go

@@ -21,7 +21,7 @@ type Metrics interface {
 
 	RecordL1Ref(name string, ref eth.L1BlockRef)
 	RecordL2Ref(name string, ref eth.L2BlockRef)
-	RecordChannelInputBytes(inputCompresedBytes int)
+	RecordChannelInputBytes(inputCompressedBytes int)
 
 	RecordUnsafePayloadsBuffer(length uint64, memSize uint64, next eth.BlockID)
 

op-node/testutils/metrics.go

@@ -11,7 +11,7 @@ type TestDerivationMetrics struct {
 	FnRecordL1Ref             func(name string, ref eth.L1BlockRef)
 	FnRecordL2Ref             func(name string, ref eth.L2BlockRef)
 	FnRecordUnsafePayloads    func(length uint64, memSize uint64, next eth.BlockID)
-	FnRecordChannelInputBytes func(inputCompresedBytes int)
+	FnRecordChannelInputBytes func(inputCompressedBytes int)
 }
 
 func (t *TestDerivationMetrics) RecordL1ReorgDepth(d uint64) {
@@ -38,9 +38,9 @@ func (t *TestDerivationMetrics) RecordUnsafePayloadsBuffer(length uint64, memSiz
 	}
 }
 
-func (t *TestDerivationMetrics) RecordChannelInputBytes(inputCompresedBytes int) {
+func (t *TestDerivationMetrics) RecordChannelInputBytes(inputCompressedBytes int) {
 	if t.FnRecordChannelInputBytes != nil {
-		t.FnRecordChannelInputBytes(inputCompresedBytes)
+		t.FnRecordChannelInputBytes(inputCompressedBytes)
 	}
 }
 

ops-bedrock/Dockerfile.l1

@@ -2,7 +2,7 @@ FROM ethereum/client-go:v1.11.2
 
 RUN apk add --no-cache jq
 
-COPY entrypoint.sh /entrypoint.sh
+COPY entrypoint-l1.sh /entrypoint.sh
 
 VOLUME ["/db"]
 

ops-bedrock/Dockerfile.l2

@@ -2,7 +2,7 @@ FROM us-docker.pkg.dev/oplabs-tools-artifacts/images/op-geth:optimism
 
 RUN apk add --no-cache jq
 
-COPY entrypoint.sh /entrypoint.sh
+COPY entrypoint-l2.sh /entrypoint.sh
 
 VOLUME ["/db"]
 

ops-bedrock/entrypoint-l2.sh

+#!/bin/sh
+set -exu
+
+VERBOSITY=${GETH_VERBOSITY:-3}
+GETH_DATA_DIR=/db
+GETH_CHAINDATA_DIR="$GETH_DATA_DIR/geth/chaindata"
+GENESIS_FILE_PATH="${GENESIS_FILE_PATH:-/genesis.json}"
+CHAIN_ID=$(cat "$GENESIS_FILE_PATH" | jq -r .config.chainId)
+RPC_PORT="${RPC_PORT:-8545}"
+WS_PORT="${WS_PORT:-8546}"
+
+if [ ! -d "$GETH_CHAINDATA_DIR" ]; then
+	echo "$GETH_CHAINDATA_DIR missing, running init"
+	echo "Initializing genesis."
+	geth --verbosity="$VERBOSITY" init \
+		--datadir="$GETH_DATA_DIR" \
+		"$GENESIS_FILE_PATH"
+else
+	echo "$GETH_CHAINDATA_DIR exists."
+fi
+
+# Warning: Archive mode is required, otherwise old trie nodes will be
+# pruned within minutes of starting the devnet.
+
+exec geth \
+	--datadir="$GETH_DATA_DIR" \
+	--verbosity="$VERBOSITY" \
+	--http \
+	--http.corsdomain="*" \
+	--http.vhosts="*" \
+	--http.addr=0.0.0.0 \
+	--http.port="$RPC_PORT" \
+	--http.api=web3,debug,eth,txpool,net,engine \
+	--ws \
+	--ws.addr=0.0.0.0 \
+	--ws.port="$WS_PORT" \
+	--ws.origins="*" \
+	--ws.api=debug,eth,txpool,net,engine \
+	--syncmode=full \
+	--nodiscover \
+	--maxpeers=0 \
+	--networkid=$CHAIN_ID \
+	--authrpc.addr="0.0.0.0" \
+	--authrpc.port="8551" \
+	--authrpc.vhosts="*" \
+	--authrpc.jwtsecret=/config/jwt-secret.txt \
+	--gcmode=archive \
+	--metrics \
+	--metrics.addr=0.0.0.0 \
+	--metrics.port=6060 \
+	"$@"

ops/check-changed/main.py

@@ -3,6 +3,7 @@ import os
 import re
 import subprocess
 import sys
+import json
 
 from github import Github
 
@@ -13,9 +14,11 @@ REBUILD_ALL_PATTERNS = [
     r'ops/check-changed/.*',
     r'^go\.mod',
     r'^go\.sum',
-    r'^pnpm-lock\.yaml',
     r'ops/check-changed/.*'
 ]
+with open("../../nx.json") as file:
+    nx_json_data = json.load(file)
+REBUILD_ALL_PATTERNS += nx_json_data["implicitDependencies"].keys()
 
 WHITELISTED_BRANCHES = {
     'master',

ops/docker/ci-builder/Dockerfile

@@ -6,10 +6,10 @@ WORKDIR /opt
 
 ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && \
-    apt-get install -y curl build-essential git && \
-    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rustup.sh && \
-    chmod +x ./rustup.sh && \
-    ./rustup.sh -y
+  apt-get install -y curl build-essential git && \
+  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rustup.sh && \
+  chmod +x ./rustup.sh && \
+  ./rustup.sh -y
 
 COPY ./.foundryrc ./.foundryrc
 
@@ -21,10 +21,10 @@ RUN git clone https://github.com/foundry-rs/foundry.git ./foundry \
 WORKDIR /opt/foundry
 
 RUN source $HOME/.profile && \
-    cargo build --release && \
-    strip /opt/foundry/target/release/forge && \
-    strip /opt/foundry/target/release/cast && \
-    strip /opt/foundry/target/release/anvil
+  cargo build --release && \
+  strip /opt/foundry/target/release/forge && \
+  strip /opt/foundry/target/release/cast && \
+  strip /opt/foundry/target/release/anvil
 
 FROM ethereum/client-go:alltools-v1.10.25 as geth
 
@@ -105,3 +105,8 @@ RUN echo "downloading mockery tool" && \
   cp mockery-tmp-dir/mockery /usr/local/bin/mockery && \
   chmod +x /usr/local/bin/mockery && \
   rm -rf mockery-tmp-dir
+
+
+RUN echo "installing mips binutils" && \
+  apt-get install -y binutils-mips-linux-gnu python3 python3-pip && \
+  pip3 install capstone pyelftools

package.json

@@ -64,6 +64,7 @@
     "patch-package": "^6.4.7",
     "prettier": "^2.8.0",
     "prettier-plugin-solidity": "^1.0.0-beta.13",
+    "rimraf": "^5.0.1",
     "ts-mocha": "^10.0.0",
     "typescript": "^4.9.3"
   },

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

@@ -7,7 +7,7 @@ import {
   waitForProvider,
 } from '@eth-optimism/common-ts'
 import { getChainId, compareAddrs } from '@eth-optimism/core-utils'
-import { Provider } from '@ethersproject/abstract-provider'
+import { Provider, TransactionResponse } from '@ethersproject/abstract-provider'
 import mainnetConfig from '@eth-optimism/contracts-bedrock/deploy-config/mainnet.json'
 import goerliConfig from '@eth-optimism/contracts-bedrock/deploy-config/goerli.json'
 import l2OutputOracleArtifactsMainnet from '@eth-optimism/contracts-bedrock/deployments/mainnet/L2OutputOracleProxy.json'
@@ -101,7 +101,7 @@ export class WalletMonService extends BaseServiceV2<
         unexpectedCalls: {
           type: Counter,
           desc: 'Number of unexpected wallets',
-          labels: ['wallet', 'target', 'nickname'],
+          labels: ['wallet', 'target', 'nickname', 'transactionHash'],
         },
         unexpectedRpcErrors: {
           type: Counter,
@@ -150,7 +150,7 @@ export class WalletMonService extends BaseServiceV2<
       number: block.number,
     })
 
-    const transactions = []
+    const transactions: TransactionResponse[] = []
     for (const txHash of block.transactions) {
       const t = await this.options.rpc.getTransaction(txHash)
       transactions.push(t)
@@ -175,11 +175,13 @@ export class WalletMonService extends BaseServiceV2<
               nickname: account.label,
               wallet: account.address,
               target: transaction.to,
+              transactionHash: transaction.hash,
             })
             this.logger.error('Unexpected call detected', {
               nickname: account.label,
               address: account.address,
               target: transaction.to,
+              transactionHash: transaction.hash,
             })
           }
         }

packages/contracts-bedrock/contracts/cannon/MIPS.sol

@@ -379,7 +379,7 @@ contract MIPS {
   }
 
   // will revert if any required input state is missing
-  function Step(bytes calldata stateData, bytes calldata proof) public returns (bytes32) {
+  function step(bytes calldata stateData, bytes calldata proof) public returns (bytes32) {
     State memory state;
     // packed data is ~6 times smaller
     assembly {

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

@@ -1563,9 +1563,17 @@ export class CrossChainMessenger {
     opts?: {
       signer?: Signer
       overrides?: Overrides
-    }
+    },
+    /**
+     * The index of the withdrawal if multiple are made with multicall
+     */
+    messageIndex: number = 0
   ): Promise<TransactionResponse> {
-    const tx = await this.populateTransaction.proveMessage(message, opts)
+    const tx = await this.populateTransaction.proveMessage(
+      message,
+      opts,
+      messageIndex
+    )
     return (opts?.signer || this.l1Signer).sendTransaction(tx)
   }
 
@@ -1584,10 +1592,18 @@ export class CrossChainMessenger {
     opts?: {
       signer?: Signer
       overrides?: PayableOverrides
-    }
+    },
+    /**
+     * The index of the withdrawal if multiple are made with multicall
+     */
+    messageIndex = 0
   ): Promise<TransactionResponse> {
     return (opts?.signer || this.l1Signer).sendTransaction(
-      await this.populateTransaction.finalizeMessage(message, opts)
+      await this.populateTransaction.finalizeMessage(
+        message,
+        opts,
+        messageIndex
+      )
     )
   }
 
@@ -1810,7 +1826,6 @@ export class CrossChainMessenger {
       opts?: {
         overrides?: Overrides
       },
-
       /**
        * The index of the withdrawal if multiple are made with multicall
        */
@@ -1822,13 +1837,17 @@ export class CrossChainMessenger {
       }
 
       if (this.bedrock) {
-        return this.populateTransaction.finalizeMessage(resolved, {
-          ...(opts || {}),
-          overrides: {
-            ...opts?.overrides,
-            gasLimit: messageGasLimit,
+        return this.populateTransaction.finalizeMessage(
+          resolved,
+          {
+            ...(opts || {}),
+            overrides: {
+              ...opts?.overrides,
+              gasLimit: messageGasLimit,
+            },
           },
-        })
+          messageIndex
+        )
       } else {
         const legacyL1XDM = new ethers.Contract(
           this.contracts.l1.L1CrossDomainMessenger.address,
@@ -1861,7 +1880,6 @@ export class CrossChainMessenger {
       opts?: {
         overrides?: PayableOverrides
       },
-
       /**
        * The index of the withdrawal if multiple are made with multicall
        */
@@ -1921,7 +1939,6 @@ export class CrossChainMessenger {
       opts?: {
         overrides?: PayableOverrides
       },
-
       /**
        * The index of the withdrawal if multiple are made with multicall
        */
@@ -2229,10 +2246,18 @@ export class CrossChainMessenger {
       message: MessageLike,
       opts?: {
         overrides?: CallOverrides
-      }
+      },
+      /**
+       * The index of the withdrawal if multiple are made with multicall
+       */
+      messageIndex = 0
     ): Promise<BigNumber> => {
       return this.l1Provider.estimateGas(
-        await this.populateTransaction.finalizeMessage(message, opts)
+        await this.populateTransaction.finalizeMessage(
+          message,
+          opts,
+          messageIndex
+        )
       )
     },
 

pnpm-lock.yaml

@@ -123,6 +123,9 @@ importers:
       prettier-plugin-solidity:
         specifier: ^1.0.0-beta.13
         version: 1.0.0-beta.18(prettier@2.8.1)
+      rimraf:
+        specifier: ^5.0.1
+        version: 5.0.1
       ts-mocha:
         specifier: ^10.0.0
         version: 10.0.0(mocha@8.4.0)
@@ -9833,7 +9836,7 @@ packages:
       fs.realpath: 1.0.0
       minimatch: 8.0.4
       minipass: 4.2.8
-      path-scurry: 1.9.2
+      path-scurry: 1.10.0
     dev: true
 
   /global-modules@2.0.0:
@@ -12149,11 +12152,6 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
-  /lru-cache@9.1.2:
-    resolution: {integrity: sha512-ERJq3FOzJTxBbFjZ7iDs+NiK4VI9Wz+RdrrAB8dio1oV+YvdPzUEE4QNiT2VD51DkIbCYRUUzCRkssXCHqSnKQ==}
-    engines: {node: 14 || >=16.14}
-    dev: true
-
   /lru_map@0.3.3:
     resolution: {integrity: sha512-Pn9cox5CsMYngeDbmChANltQl+5pi6XmTrraMSzhPmMBbmgcxmqWry0U3PGapCU1yB4/LqCcom7qhHZiF/jGfQ==}
 
@@ -14531,14 +14529,6 @@ packages:
       minipass: 6.0.2
     dev: true
 
-  /path-scurry@1.9.2:
-    resolution: {integrity: sha512-qSDLy2aGFPm8i4rsbHd4MNyTcrzHFsLQykrtbuGRknZZCBBVXSv2tSCDN2Cg6Rt/GFRw8GoW9y9Ecw5rIPG1sg==}
-    engines: {node: '>=16 || 14 >=14.17'}
-    dependencies:
-      lru-cache: 9.1.2
-      minipass: 6.0.2
-    dev: true
-
   /path-to-regexp@0.1.7:
     resolution: {integrity: sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==}
 
@@ -15807,6 +15797,14 @@ packages:
       glob: 9.3.5
     dev: true
 
+  /rimraf@5.0.1:
+    resolution: {integrity: sha512-OfFZdwtd3lZ+XZzYP/6gTACubwFcHdLRqS9UX3UwpU2dnGQYkPFISRwvM3w9IiB2w7bW5qGo/uAwE4SmXXSKvg==}
+    engines: {node: '>=14'}
+    hasBin: true
+    dependencies:
+      glob: 10.3.1
+    dev: true
+
   /ripemd160@2.0.2:
     resolution: {integrity: sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==}
     dependencies: