Merge branch 'develop' into jm/monitoring/split-1

op-batcher/cmd/main.go

@@ -13,7 +13,7 @@ import (
 )
 
 var (
-	Version   = "v0.10.4"
+	Version   = "v0.10.5"
 	GitCommit = ""
 	GitDate   = ""
 )

op-batcher/go.mod

@@ -4,9 +4,9 @@ go 1.18
 
 require (
 	github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3
-	github.com/ethereum-optimism/optimism/op-node v0.10.4
-	github.com/ethereum-optimism/optimism/op-proposer v0.10.4
-	github.com/ethereum-optimism/optimism/op-service v0.10.4
+	github.com/ethereum-optimism/optimism/op-node v0.10.5
+	github.com/ethereum-optimism/optimism/op-proposer v0.10.5
+	github.com/ethereum-optimism/optimism/op-service v0.10.5
 	github.com/ethereum/go-ethereum v1.10.26
 	github.com/urfave/cli v1.22.9
 )
@@ -23,7 +23,7 @@ require (
 	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
 	github.com/deckarep/golang-set v1.8.0 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect
-	github.com/ethereum-optimism/optimism/op-bindings v0.10.4 // indirect
+	github.com/ethereum-optimism/optimism/op-bindings v0.10.5 // indirect
 	github.com/fjl/memsize v0.0.1 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect

op-batcher/go.sum

@@ -106,14 +106,14 @@ github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3 h1:RWHKLhCrQThMfch+QJ1Z
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3/go.mod h1:QziizLAiF0KqyLdNJYD7O5cpDlaFMNZzlxYNcWsJUxs=
 github.com/ethereum-optimism/op-geth v0.0.0-20221216190603-60b51d600468 h1:7KgjBYDji5AKi42eRYI+n8Gs+ZJVilSASL3WBu82c3M=
 github.com/ethereum-optimism/op-geth v0.0.0-20221216190603-60b51d600468/go.mod h1:p0Yox74PhYlq1HvijrCBCD9A3cI7rXco7hT6KrQr+rY=
-github.com/ethereum-optimism/optimism/op-bindings v0.10.4 h1:CFn4+t0FUrBG5DmkKyYrLbGmzHWLdLv8QdUnlklvozc=
-github.com/ethereum-optimism/optimism/op-bindings v0.10.4/go.mod h1:philKV8erP02ggjk2mRIdvJd2ZjMzpmqu0+zwwzKmNw=
-github.com/ethereum-optimism/optimism/op-node v0.10.4 h1:ZXqfrFKgb6W4ZLbkfO9NlgaQ1djBCCPzNGbd6TgehVI=
-github.com/ethereum-optimism/optimism/op-node v0.10.4/go.mod h1:avOLjMLxzB5QB7HmiLlpNkyS93QVHdr0AttRdfYGX3Y=
-github.com/ethereum-optimism/optimism/op-proposer v0.10.4 h1:X81vdig8CeiDrhPjQjCOc/eDBlOLcakppy+F4Sngk0E=
-github.com/ethereum-optimism/optimism/op-proposer v0.10.4/go.mod h1:2WlzvnX23uOfgMsTF2UKKLb0PT9AqQOIm6OgtWTn1TQ=
-github.com/ethereum-optimism/optimism/op-service v0.10.4 h1:WKqNyOBkdJ0ZdlGiDPROZMaWfYxpsYjA5Anb0Bkl5m4=
-github.com/ethereum-optimism/optimism/op-service v0.10.4/go.mod h1:7INvNCJGwVgNT4gz9Yupx7PAEJeu+F/JtHKv1fOr+9Q=
+github.com/ethereum-optimism/optimism/op-bindings v0.10.5 h1:CcVHlC1QW3z6X/GYhwRfx7gz3WWho6hnVObzuNDLUS4=
+github.com/ethereum-optimism/optimism/op-bindings v0.10.5/go.mod h1:9ZSUq/rjlzp3uYyBN4sZmhTc3oZgDVqJ4wrUja7vj6c=
+github.com/ethereum-optimism/optimism/op-node v0.10.5 h1:Fp9xzbcfqGQEicpbrcWKED2uqZOSZscID7aN56KDTok=
+github.com/ethereum-optimism/optimism/op-node v0.10.5/go.mod h1:GPsNceaHhDJZcxH7CsdJYuqAqUuE9xz69MzO7Qu6doo=
+github.com/ethereum-optimism/optimism/op-proposer v0.10.5 h1:bpw3D3yVg1XLDy5VC5KKWvGYa3zDsat9GLxXCs4dNQE=
+github.com/ethereum-optimism/optimism/op-proposer v0.10.5/go.mod h1:6zXmBmtwdvvzVeWoQmgR5bPn/VHOm8Vh8y8LVxjsneo=
+github.com/ethereum-optimism/optimism/op-service v0.10.5 h1:N0hG156WHOP0C60rkN0JI8hWkmKW5LvR4pppSgJiU4M=
+github.com/ethereum-optimism/optimism/op-service v0.10.5/go.mod h1:wbtHqi1fv00B3agj7a2zdP3OFanEfGZ23zPgGgFCF/c=
 github.com/fjl/memsize v0.0.1 h1:+zhkb+dhUgx0/e+M8sF0QqiouvMQUiKR+QYvdxIOKcQ=
 github.com/fjl/memsize v0.0.1/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=

op-chain-ops/cmd/op-migrate/main.go

@@ -195,7 +195,7 @@ func main() {
 				return err
 			}
 
-			if err := genesis.CheckMigratedDB(postLDB); err != nil {
+			if err := genesis.PostCheckMigratedDB(postLDB, migrationData, &config.L1CrossDomainMessengerProxy, config.L1ChainID); err != nil {
 				return err
 			}
 

op-chain-ops/ether/migrate.go

@@ -29,7 +29,6 @@ var (
 		// Symbol
 		common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"): true,
 		common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000005"): true,
-		// Total supply
 		common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000006"): true,
 	}
 )
@@ -40,7 +39,7 @@ func MigrateLegacyETH(db ethdb.Database, stateDB *state.StateDB, addresses []com
 	// Set of storage slots that we expect to see in the OVM ETH contract.
 	storageSlotsToMigrate := make(map[common.Hash]int)
 	// Chain params to use for integrity checking.
-	params := ParamsByChainID[chainID]
+	params := migration.ParamsByChainID[chainID]
 	if params == nil {
 		return fmt.Errorf("no chain params for %d", chainID)
 	}

op-chain-ops/genesis/check.go

 package genesis
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"math/big"
 
+	"github.com/ethereum-optimism/optimism/op-chain-ops/crossdomain"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis/migration"
+	"github.com/ethereum/go-ethereum/crypto"
+
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
-	"github.com/ethereum-optimism/optimism/op-chain-ops/ether"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
@@ -16,8 +20,25 @@ import (
 	"github.com/ethereum/go-ethereum/trie"
 )
 
-// CheckMigratedDB will check that the migration was performed correctly
-func CheckMigratedDB(ldb ethdb.Database) error {
+// MaxSlotChecks is the maximum number of storage slots to check
+// when validating the untouched predeploys. This limit is in place
+// to bound execution time of the migration. We can parallelize this
+// in the future.
+const MaxSlotChecks = 1000
+
+var LegacyETHCheckSlots = map[common.Hash]common.Hash{
+	// Bridge
+	common.Hash{31: 0x06}: common.HexToHash("0x0000000000000000000000004200000000000000000000000000000000000010"),
+	// Symbol
+	common.Hash{31: 0x04}: common.HexToHash("0x4554480000000000000000000000000000000000000000000000000000000006"),
+	// Name
+	common.Hash{31: 0x03}: common.HexToHash("0x457468657200000000000000000000000000000000000000000000000000000a"),
+	// Total supply
+	common.Hash{31: 0x02}: {},
+}
+
+// PostCheckMigratedDB will check that the migration was performed correctly
+func PostCheckMigratedDB(ldb ethdb.Database, migrationData migration.MigrationData, l1XDM *common.Address, l1ChainID uint64) error {
 	log.Info("Validating database migration")
 
 	hash := rawdb.ReadHeadHeaderHash(ldb)
@@ -30,6 +51,13 @@ func CheckMigratedDB(ldb ethdb.Database) error {
 	header := rawdb.ReadHeader(ldb, hash, *num)
 	log.Info("Read header from database", "number", *num)
 
+	if !bytes.Equal(header.Extra, bedrockTransitionBlockExtraData) {
+		return fmt.Errorf("expected extra data to be %x, but got %x", bedrockTransitionBlockExtraData, header.Extra)
+	}
+
+	prevHeader := rawdb.ReadHeader(ldb, header.ParentHash, *num-1)
+	log.Info("Read previous header from database", "number", *num-1)
+
 	underlyingDB := state.NewDatabaseWithConfig(ldb, &trie.Config{
 		Preimages: true,
 	})
@@ -39,22 +67,82 @@ func CheckMigratedDB(ldb ethdb.Database) error {
 		return fmt.Errorf("cannot open StateDB: %w", err)
 	}
 
-	if err := CheckPredeploys(db); err != nil {
+	if err := PostCheckUntouchables(underlyingDB, db, prevHeader.Root, l1ChainID); err != nil {
+		return err
+	}
+	log.Info("checked untouchables")
+
+	if err := PostCheckPredeploys(db); err != nil {
 		return err
 	}
 	log.Info("checked predeploys")
 
-	if err := CheckLegacyETH(db); err != nil {
+	if err := PostCheckLegacyETH(db); err != nil {
 		return err
 	}
 	log.Info("checked legacy eth")
 
+	if err := CheckWithdrawalsAfter(db, migrationData, l1XDM); err != nil {
+		return err
+	}
+	log.Info("checked withdrawals")
+
 	return nil
 }
 
-// CheckPredeploys will check that there is code at each predeploy
+// PostCheckUntouchables will check that the untouchable contracts have
+// not been modified by the migration process.
+func PostCheckUntouchables(udb state.Database, currDB *state.StateDB, prevRoot common.Hash, l1ChainID uint64) error {
+	prevDB, err := state.New(prevRoot, udb, nil)
+	if err != nil {
+		return fmt.Errorf("cannot open StateDB: %w", err)
+	}
+
+	for addr := range UntouchablePredeploys {
+		// Check that the code is the same.
+		code := currDB.GetCode(addr)
+		hash := crypto.Keccak256Hash(code)
+		expHash := UntouchableCodeHashes[addr][l1ChainID]
+		if hash != expHash {
+			return fmt.Errorf("expected code hash for %s to be %s, but got %s", addr, expHash, hash)
+		}
+		log.Info("checked code hash", "address", addr, "hash", hash)
+
+		// Ensure that the current/previous roots match
+		prevRoot := prevDB.StorageTrie(addr).Hash()
+		currRoot := currDB.StorageTrie(addr).Hash()
+		if prevRoot != currRoot {
+			return fmt.Errorf("expected storage root for %s to be %s, but got %s", addr, prevRoot, currRoot)
+		}
+		log.Info("checked account roots", "address", addr, "curr_root", currRoot, "prev_root", prevRoot)
+
+		// Sample storage slots to ensure that they are not modified.
+		var count int
+		expSlots := make(map[common.Hash]common.Hash)
+		err := prevDB.ForEachStorage(addr, func(key, value common.Hash) bool {
+			count++
+			expSlots[key] = value
+			return count < MaxSlotChecks
+		})
+		if err != nil {
+			return fmt.Errorf("error iterating over storage: %w", err)
+		}
+
+		for expKey, expValue := range expSlots {
+			actValue := currDB.GetState(addr, expKey)
+			if actValue != expValue {
+				return fmt.Errorf("expected slot %s on %s to be %s, but got %s", expKey, addr, expValue, actValue)
+			}
+		}
+
+		log.Info("checked storage", "address", addr, "count", count)
+	}
+	return nil
+}
+
+// PostCheckPredeploys will check that there is code at each predeploy
 // address
-func CheckPredeploys(db vm.StateDB) error {
+func PostCheckPredeploys(db *state.StateDB) error {
 	for i := uint64(0); i <= 2048; i++ {
 		// Compute the predeploy address
 		bigAddr := new(big.Int).Or(bigL2PredeployNamespace, new(big.Int).SetUint64(i))
@@ -66,46 +154,138 @@ func CheckPredeploys(db vm.StateDB) error {
 			return fmt.Errorf("no code found at predeploy %s", addr)
 		}
 
+		if UntouchablePredeploys[addr] {
+			log.Trace("skipping untouchable predeploy", "address", addr)
+			continue
+		}
+
 		// There must be an admin
 		admin := db.GetState(addr, AdminSlot)
 		adminAddr := common.BytesToAddress(admin.Bytes())
 		if addr != predeploys.ProxyAdminAddr && addr != predeploys.GovernanceTokenAddr && adminAddr != predeploys.ProxyAdminAddr {
-			return fmt.Errorf("admin is %s when it should be %s for %s", adminAddr, predeploys.ProxyAdminAddr, addr)
+			return fmt.Errorf("expected admin for %s to be %s but got %s", addr, predeploys.ProxyAdminAddr, adminAddr)
 		}
 	}
 
 	// For each predeploy, check that we've set the implementation correctly when
 	// necessary and that there's code at the implementation.
 	for _, proxyAddr := range predeploys.Predeploys {
-		implAddr, special, err := mapImplementationAddress(proxyAddr)
-		if err != nil {
-			return err
+		if UntouchablePredeploys[*proxyAddr] {
+			log.Trace("skipping untouchable predeploy", "address", proxyAddr)
+			continue
+		}
+
+		if *proxyAddr == predeploys.LegacyERC20ETHAddr {
+			log.Trace("skipping legacy eth predeploy")
+			continue
 		}
 
-		if !special {
-			impl := db.GetState(*proxyAddr, ImplementationSlot)
-			implAddr := common.BytesToAddress(impl.Bytes())
-			if implAddr == (common.Address{}) {
-				return fmt.Errorf("no implementation for %s", *proxyAddr)
+		if *proxyAddr == predeploys.ProxyAdminAddr {
+			implCode := db.GetCode(*proxyAddr)
+			if len(implCode) == 0 {
+				return errors.New("no code found at proxy admin")
 			}
+			continue
 		}
 
-		implCode := db.GetCode(implAddr)
+		expImplAddr, err := AddressToCodeNamespace(*proxyAddr)
+		if err != nil {
+			return fmt.Errorf("error converting to code namespace: %w", err)
+		}
+
+		implCode := db.GetCode(expImplAddr)
 		if len(implCode) == 0 {
 			return fmt.Errorf("no code found at predeploy impl %s", *proxyAddr)
 		}
+
+		impl := db.GetState(*proxyAddr, ImplementationSlot)
+		actImplAddr := common.BytesToAddress(impl.Bytes())
+		if expImplAddr != actImplAddr {
+			return fmt.Errorf("expected implementation for %s to be at %s, but got %s", *proxyAddr, expImplAddr, actImplAddr)
+		}
 	}
 
 	return nil
 }
 
-// CheckLegacyETH checks that the legacy eth migration was successful.
+// PostCheckLegacyETH checks that the legacy eth migration was successful.
 // It currently only checks that the total supply was set to 0.
-func CheckLegacyETH(db vm.StateDB) error {
-	// Ensure total supply is set to 0
-	slot := db.GetState(predeploys.LegacyERC20ETHAddr, ether.GetOVMETHTotalSupplySlot())
-	if slot != (common.Hash{}) {
-		return errors.New("total supply not set to 0")
+func PostCheckLegacyETH(db vm.StateDB) error {
+	for slot, expValue := range LegacyETHCheckSlots {
+		actValue := db.GetState(predeploys.LegacyERC20ETHAddr, slot)
+		if actValue != expValue {
+			return fmt.Errorf("expected slot %s on %s to be %s, but got %s", slot, predeploys.LegacyERC20ETHAddr, expValue, actValue)
+		}
+	}
+	return nil
+}
+
+func CheckWithdrawalsAfter(db vm.StateDB, data migration.MigrationData, l1CrossDomainMessenger *common.Address) error {
+	wds, err := data.ToWithdrawals()
+	if err != nil {
+		return err
+	}
+
+	// First, make a mapping between old withdrawal slots and new ones.
+	// This list can be a superset of what was actually migrated, since
+	// some witness data may references withdrawals that reverted.
+	oldToNew := make(map[common.Hash]common.Hash)
+	for _, wd := range wds {
+		migrated, err := crossdomain.MigrateWithdrawal(wd, l1CrossDomainMessenger)
+		if err != nil {
+			return err
+		}
+
+		legacySlot, err := wd.StorageSlot()
+		if err != nil {
+			return fmt.Errorf("cannot compute legacy storage slot: %w", err)
+		}
+		migratedSlot, err := migrated.StorageSlot()
+		if err != nil {
+			return fmt.Errorf("cannot compute migrated storage slot: %w", err)
+		}
+
+		oldToNew[legacySlot] = migratedSlot
+	}
+
+	// Now, iterate over each legacy withdrawal and check if there is a corresponding
+	// migrated withdrawal.
+	var innerErr error
+	err = db.ForEachStorage(predeploys.LegacyMessagePasserAddr, func(key, value common.Hash) bool {
+		// The legacy message passer becomes a proxy during the migration,
+		// so we need to ignore the implementation/admin slots.
+		if key == ImplementationSlot || key == AdminSlot {
+			return true
+		}
+
+		// All other values should be abiTrue, since the only other state
+		// in the message passer is the mapping of messages to boolean true.
+		if value != abiTrue {
+			innerErr = fmt.Errorf("non-true value found in legacy message passer. key: %s, value: %s", key, value)
+			return false
+		}
+
+		// Grab the migrated slot.
+		migratedSlot := oldToNew[key]
+		if migratedSlot == (common.Hash{}) {
+			innerErr = fmt.Errorf("no migrated slot found for legacy slot %s", key)
+			return false
+		}
+
+		// Look up the migrated slot in the DB, and make sure it is abiTrue.
+		migratedValue := db.GetState(predeploys.L2ToL1MessagePasserAddr, migratedSlot)
+		if migratedValue != abiTrue {
+			innerErr = fmt.Errorf("expected migrated value to be true, but got %s", migratedValue)
+			return false
+		}
+
+		return true
+	})
+	if err != nil {
+		return fmt.Errorf("error iterating storage slots: %w", err)
+	}
+	if innerErr != nil {
+		return fmt.Errorf("error checking storage slots: %w", innerErr)
 	}
 	return nil
 }

op-chain-ops/genesis/db_migration.go

@@ -5,16 +5,14 @@ import (
 	"fmt"
 	"math/big"
 
-	"github.com/ethereum-optimism/optimism/op-chain-ops/ether"
-
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/crossdomain"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/ether"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis/migration"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
@@ -70,6 +68,7 @@ func MigrateDB(ldb ethdb.Database, config *DeployConfig, l1Block *types.Block, m
 
 	underlyingDB := state.NewDatabaseWithConfig(ldb, &trie.Config{
 		Preimages: true,
+		Cache:     1024,
 	})
 
 	db, err := state.New(header.Root, underlyingDB, nil)
@@ -78,19 +77,22 @@ func MigrateDB(ldb ethdb.Database, config *DeployConfig, l1Block *types.Block, m
 	}
 
 	// Convert all of the messages into legacy withdrawals
-	withdrawals, err := migrationData.ToWithdrawals()
+	unfilteredWithdrawals, err := migrationData.ToWithdrawals()
 	if err != nil {
 		return nil, fmt.Errorf("cannot serialize withdrawals: %w", err)
 	}
 
+	var filteredWithdrawals []*crossdomain.LegacyWithdrawal
 	if !noCheck {
 		log.Info("Checking withdrawals...")
-		if err := CheckWithdrawals(db, withdrawals); err != nil {
+		filteredWithdrawals, err = PreCheckWithdrawals(db, unfilteredWithdrawals)
+		if err != nil {
 			return nil, fmt.Errorf("withdrawals mismatch: %w", err)
 		}
 		log.Info("Withdrawals accounted for!")
 	} else {
 		log.Info("Skipping checking withdrawals")
+		filteredWithdrawals = unfilteredWithdrawals
 	}
 
 	// Now start the migration
@@ -113,8 +115,12 @@ func MigrateDB(ldb ethdb.Database, config *DeployConfig, l1Block *types.Block, m
 		return nil, fmt.Errorf("cannot set implementations: %w", err)
 	}
 
+	if err := SetLegacyETH(db, storage, immutable); err != nil {
+		return nil, fmt.Errorf("cannot set legacy ETH: %w", err)
+	}
+
 	log.Info("Starting to migrate withdrawals", "no-check", noCheck)
-	err = crossdomain.MigrateWithdrawals(withdrawals, db, &config.L1CrossDomainMessengerProxy, noCheck)
+	err = crossdomain.MigrateWithdrawals(filteredWithdrawals, db, &config.L1CrossDomainMessengerProxy, noCheck)
 	if err != nil {
 		return nil, fmt.Errorf("cannot migrate withdrawals: %w", err)
 	}
@@ -132,7 +138,7 @@ func MigrateDB(ldb ethdb.Database, config *DeployConfig, l1Block *types.Block, m
 	if err != nil {
 		return nil, err
 	}
-	log.Info("committing state DB", "root", newRoot)
+	log.Info("committed state DB", "root", newRoot)
 
 	// Set the amount of gas used so that EIP 1559 starts off stable
 	gasUsed := (uint64)(config.L2GenesisBlockGasLimit) * config.EIP1559Elasticity
@@ -232,47 +238,60 @@ func MigrateDB(ldb ethdb.Database, config *DeployConfig, l1Block *types.Block, m
 	return res, nil
 }
 
-// CheckWithdrawals will ensure that the entire list of withdrawals is being
+// PreCheckWithdrawals will ensure that the entire list of withdrawals is being
 // operated on during the database migration.
-func CheckWithdrawals(db vm.StateDB, withdrawals []*crossdomain.LegacyWithdrawal) error {
+func PreCheckWithdrawals(db *state.StateDB, withdrawals []*crossdomain.LegacyWithdrawal) ([]*crossdomain.LegacyWithdrawal, error) {
 	// Create a mapping of all of their storage slots
-	knownSlots := make(map[common.Hash]bool)
+	slotsWds := make(map[common.Hash]*crossdomain.LegacyWithdrawal)
 	for _, wd := range withdrawals {
 		slot, err := wd.StorageSlot()
 		if err != nil {
-			return fmt.Errorf("cannot check withdrawals: %w", err)
+			return nil, fmt.Errorf("cannot check withdrawals: %w", err)
 		}
-		knownSlots[slot] = true
+
+		slotsWds[slot] = wd
 	}
+
 	// Build a map of all the slots in the LegacyMessagePasser
+	var count int
 	slots := make(map[common.Hash]bool)
 	err := db.ForEachStorage(predeploys.LegacyMessagePasserAddr, func(key, value common.Hash) bool {
 		if value != abiTrue {
 			return false
 		}
 		slots[key] = true
+		count++
 		return true
 	})
+
 	if err != nil {
-		return fmt.Errorf("cannot iterate over LegacyMessagePasser: %w", err)
+		return nil, fmt.Errorf("cannot iterate over LegacyMessagePasser: %w", err)
 	}
 
+	log.Info("iterated legacy messages", "count", count)
+
 	// Check that all of the slots from storage correspond to a known message
 	for slot := range slots {
-		_, ok := knownSlots[slot]
+		_, ok := slotsWds[slot]
 		if !ok {
-			return fmt.Errorf("Unknown storage slot in state: %s", slot)
+			return nil, fmt.Errorf("Unknown storage slot in state: %s", slot)
 		}
 	}
+
+	filtered := make([]*crossdomain.LegacyWithdrawal, 0)
+
 	// Check that all of the input messages are legit
-	for slot := range knownSlots {
+	for slot := range slotsWds {
 		//nolint:staticcheck
 		_, ok := slots[slot]
 		//nolint:staticcheck
 		if !ok {
-			return fmt.Errorf("Unknown input message: %s", slot)
+			log.Info("filtering out unknown input message", "slot", slot.String())
+			continue
 		}
+
+		filtered = append(filtered, slotsWds[slot])
 	}
 
-	return nil
+	return filtered, nil
 }

op-chain-ops/genesis/layer_two.go

@@ -22,22 +22,17 @@ func BuildL2DeveloperGenesis(config *DeployConfig, l1StartBlock *types.Block) (*
 	}
 	SetPrecompileBalances(db)
 
-	return BuildL2Genesis(db, config, l1StartBlock)
-}
-
-// BuildL2Genesis will build the L2 Optimism Genesis Block
-func BuildL2Genesis(db *state.MemoryStateDB, config *DeployConfig, l1Block *types.Block) (*core.Genesis, error) {
-	if err := SetL2Proxies(db); err != nil {
+	storage, err := NewL2StorageConfig(config, l1StartBlock)
+	if err != nil {
 		return nil, err
 	}
 
-	storage, err := NewL2StorageConfig(config, l1Block)
+	immutable, err := NewL2ImmutableConfig(config, l1StartBlock)
 	if err != nil {
 		return nil, err
 	}
 
-	immutable, err := NewL2ImmutableConfig(config, l1Block)
-	if err != nil {
+	if err := SetL2Proxies(db); err != nil {
 		return nil, err
 	}
 
@@ -45,5 +40,9 @@ func BuildL2Genesis(db *state.MemoryStateDB, config *DeployConfig, l1Block *type
 		return nil, err
 	}
 
+	if err := SetDevOnlyL2Implementations(db, storage, immutable); err != nil {
+		return nil, err
+	}
+
 	return db.Genesis(), nil
 }

op-chain-ops/genesis/layer_two_test.go

@@ -56,7 +56,7 @@ func TestBuildL2DeveloperGenesis(t *testing.T) {
 		require.Equal(t, ok, true)
 		require.Greater(t, len(account.Code), 0)
 
-		if name == "GovernanceToken" || name == "LegacyERC20ETH" || name == "ProxyAdmin" {
+		if name == "GovernanceToken" || name == "LegacyERC20ETH" || name == "ProxyAdmin" || name == "WETH9" {
 			continue
 		}
 
@@ -65,7 +65,7 @@ func TestBuildL2DeveloperGenesis(t *testing.T) {
 		require.Equal(t, adminSlot, predeploys.ProxyAdminAddr.Hash())
 		require.Equal(t, account.Code, depB)
 	}
-	require.Equal(t, 2343, len(gen.Alloc))
+	require.Equal(t, 2342, len(gen.Alloc))
 
 	if writeFile {
 		file, _ := json.MarshalIndent(gen, "", " ")
@@ -92,5 +92,5 @@ func TestBuildL2DeveloperGenesisDevAccountsFunding(t *testing.T) {
 
 	gen, err := genesis.BuildL2DeveloperGenesis(config, block)
 	require.NoError(t, err)
-	require.Equal(t, 2321, len(gen.Alloc))
+	require.Equal(t, 2320, len(gen.Alloc))
 }

op-chain-ops/ether/params.go → op-chain-ops/genesis/migration/params.go

-package ether
+package migration
 
 import (
 	"math/big"

op-chain-ops/genesis/setters.go

@@ -14,6 +14,28 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
+// UntouchablePredeploys are addresses in the predeploy namespace
+// that should not be touched by the migration process.
+var UntouchablePredeploys = map[common.Address]bool{
+	predeploys.GovernanceTokenAddr: true,
+	predeploys.WETH9Addr:           true,
+}
+
+// UntouchableCodeHashes contains code hashes of all the contracts
+// that should not be touched by the migration process.
+type ChainHashMap map[uint64]common.Hash
+
+var UntouchableCodeHashes = map[common.Address]ChainHashMap{
+	predeploys.GovernanceTokenAddr: {
+		1: common.HexToHash("0x8551d935f4e67ad3c98609f0d9f0f234740c4c4599f82674633b55204393e07f"),
+		5: common.HexToHash("0xc4a213cf5f06418533e5168d8d82f7ccbcc97f27ab90197c2c051af6a4941cf9"),
+	},
+	predeploys.WETH9Addr: {
+		1: common.HexToHash("0x779bbf2a738ef09d961c945116197e2ac764c1b39304b2b4418cd4e42668b173"),
+		5: common.HexToHash("0x779bbf2a738ef09d961c945116197e2ac764c1b39304b2b4418cd4e42668b173"),
+	},
+}
+
 // FundDevAccounts will fund each of the development accounts.
 func FundDevAccounts(db vm.StateDB) {
 	for _, account := range DevAccounts {
@@ -48,15 +70,15 @@ func setProxies(db vm.StateDB, proxyAdminAddr common.Address, namespace *big.Int
 		bigAddr := new(big.Int).Or(namespace, new(big.Int).SetUint64(i))
 		addr := common.BigToAddress(bigAddr)
 
-		// There is no proxy at the governance token address or
-		// the proxy admin address. LegacyERC20ETH lives in the
-		// 0xDead namespace so it can be ignored here
-		if addr == predeploys.GovernanceTokenAddr || addr == predeploys.ProxyAdminAddr {
+		if UntouchablePredeploys[addr] || addr == predeploys.ProxyAdminAddr {
 			log.Info("Skipping setting proxy", "address", addr)
 			continue
 		}
 
-		db.CreateAccount(addr)
+		if !db.Exist(addr) {
+			db.CreateAccount(addr)
+		}
+
 		db.SetCode(addr, depBytecode)
 		db.SetState(addr, AdminSlot, proxyAdminAddr.Hash())
 		log.Trace("Set proxy", "address", addr, "admin", proxyAdminAddr)
@@ -64,7 +86,16 @@ func setProxies(db vm.StateDB, proxyAdminAddr common.Address, namespace *big.Int
 	return nil
 }
 
-// SetImplementations will set the implmentations of the contracts in the state
+func SetLegacyETH(db vm.StateDB, storage state.StorageConfig, immutable immutables.ImmutableConfig) error {
+	deployResults, err := immutables.BuildOptimism(immutable)
+	if err != nil {
+		return err
+	}
+
+	return setupPredeploy(db, deployResults, storage, "LegacyERC20ETH", predeploys.LegacyERC20ETHAddr, predeploys.LegacyERC20ETHAddr)
+}
+
+// SetImplementations will set the implementations of the contracts in the state
 // and configure the proxies to point to the implementations. It also sets
 // the appropriate storage values for each contract at the proxy address.
 func SetImplementations(db vm.StateDB, storage state.StorageConfig, immutable immutables.ImmutableConfig) error {
@@ -74,47 +105,72 @@ func SetImplementations(db vm.StateDB, storage state.StorageConfig, immutable im
 	}
 
 	for name, address := range predeploys.Predeploys {
-		// Convert the address to the code address unless it is
-		// designed to not be behind a proxy
-		addr, special, err := mapImplementationAddress(address)
+		if UntouchablePredeploys[*address] {
+			continue
+		}
+
+		if *address == predeploys.LegacyERC20ETHAddr {
+			continue
+		}
+
+		codeAddr, err := AddressToCodeNamespace(*address)
 		if err != nil {
+			return fmt.Errorf("error converting to code namespace: %w", err)
+		}
+
+		// Proxy admin is a special case - it needs an impl set, but at its own address
+		if *address == predeploys.ProxyAdminAddr {
+			codeAddr = *address
+		}
+
+		if !db.Exist(codeAddr) {
+			db.CreateAccount(codeAddr)
+		}
+
+		if *address != predeploys.ProxyAdminAddr {
+			db.SetState(*address, ImplementationSlot, codeAddr.Hash())
+		}
+
+		if err := setupPredeploy(db, deployResults, storage, name, *address, codeAddr); err != nil {
 			return err
 		}
 
-		if !special {
-			db.SetState(*address, ImplementationSlot, addr.Hash())
+		code := db.GetCode(codeAddr)
+		if len(code) == 0 {
+			return fmt.Errorf("code not set for %s", name)
 		}
+	}
+	return nil
+}
 
-		// Create the account
-		db.CreateAccount(addr)
+func SetDevOnlyL2Implementations(db vm.StateDB, storage state.StorageConfig, immutable immutables.ImmutableConfig) error {
+	deployResults, err := immutables.BuildOptimism(immutable)
+	if err != nil {
+		return err
+	}
 
-		// Use the genrated bytecode when there are immutables
-		// otherwise use the artifact deployed bytecode
-		if bytecode, ok := deployResults[name]; ok {
-			log.Info("Setting deployed bytecode with immutables", "name", name, "address", addr)
-			db.SetCode(addr, bytecode)
-		} else {
-			depBytecode, err := bindings.GetDeployedBytecode(name)
-			if err != nil {
-				return err
-			}
-			log.Info("Setting deployed bytecode from solc compiler output", "name", name, "address", addr)
-			db.SetCode(addr, depBytecode)
+	for name, address := range predeploys.Predeploys {
+		if !UntouchablePredeploys[*address] {
+			continue
 		}
 
-		// Set the storage values
-		if storageConfig, ok := storage[name]; ok {
-			log.Info("Setting storage", "name", name, "address", *address)
-			if err := state.SetStorage(name, *address, storageConfig, db); err != nil {
-				return err
-			}
+		db.CreateAccount(*address)
+
+		if err := setupPredeploy(db, deployResults, storage, name, *address, *address); err != nil {
+			return err
 		}
 
-		code := db.GetCode(addr)
+		code := db.GetCode(*address)
 		if len(code) == 0 {
 			return fmt.Errorf("code not set for %s", name)
 		}
 	}
+
+	db.CreateAccount(predeploys.LegacyERC20ETHAddr)
+	if err := setupPredeploy(db, deployResults, storage, "LegacyERC20ETH", predeploys.LegacyERC20ETHAddr, predeploys.LegacyERC20ETHAddr); err != nil {
+		return fmt.Errorf("error setting up legacy eth: %w", err)
+	}
+
 	return nil
 }
 
@@ -129,22 +185,28 @@ func SetPrecompileBalances(db vm.StateDB) {
 	}
 }
 
-func mapImplementationAddress(addrP *common.Address) (common.Address, bool, error) {
-	var addr common.Address
-	var err error
-	var special bool
-	switch *addrP {
-	case predeploys.GovernanceTokenAddr:
-		addr = predeploys.GovernanceTokenAddr
-		special = true
-	case predeploys.LegacyERC20ETHAddr:
-		addr = predeploys.LegacyERC20ETHAddr
-		special = true
-	case predeploys.ProxyAdminAddr:
-		addr = predeploys.ProxyAdminAddr
-		special = true
-	default:
-		addr, err = AddressToCodeNamespace(*addrP)
+func setupPredeploy(db vm.StateDB, deployResults immutables.DeploymentResults, storage state.StorageConfig, name string, proxyAddr common.Address, implAddr common.Address) error {
+	// Use the generated bytecode when there are immutables
+	// otherwise use the artifact deployed bytecode
+	if bytecode, ok := deployResults[name]; ok {
+		log.Info("Setting deployed bytecode with immutables", "name", name, "address", implAddr)
+		db.SetCode(implAddr, bytecode)
+	} else {
+		depBytecode, err := bindings.GetDeployedBytecode(name)
+		if err != nil {
+			return err
+		}
+		log.Info("Setting deployed bytecode from solc compiler output", "name", name, "address", implAddr)
+		db.SetCode(implAddr, depBytecode)
 	}
-	return addr, special, err
+
+	// Set the storage values
+	if storageConfig, ok := storage[name]; ok {
+		log.Info("Setting storage", "name", name, "address", proxyAddr)
+		if err := state.SetStorage(name, proxyAddr, storageConfig, db); err != nil {
+			return err
+		}
+	}
+
+	return nil
 }

op-chain-ops/go.mod

@@ -3,7 +3,7 @@ module github.com/ethereum-optimism/optimism/op-chain-ops
 go 1.18
 
 require (
-	github.com/ethereum-optimism/optimism/op-bindings v0.10.4
+	github.com/ethereum-optimism/optimism/op-bindings v0.10.5
 	github.com/ethereum-optimism/optimism/op-node v0.10.1
 	github.com/ethereum/go-ethereum v1.10.26
 	github.com/holiman/uint256 v1.2.0

op-chain-ops/go.sum

@@ -77,8 +77,8 @@ github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.m
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/ethereum-optimism/op-geth v0.0.0-20221216190603-60b51d600468 h1:7KgjBYDji5AKi42eRYI+n8Gs+ZJVilSASL3WBu82c3M=
 github.com/ethereum-optimism/op-geth v0.0.0-20221216190603-60b51d600468/go.mod h1:p0Yox74PhYlq1HvijrCBCD9A3cI7rXco7hT6KrQr+rY=
-github.com/ethereum-optimism/optimism/op-bindings v0.10.4 h1:CFn4+t0FUrBG5DmkKyYrLbGmzHWLdLv8QdUnlklvozc=
-github.com/ethereum-optimism/optimism/op-bindings v0.10.4/go.mod h1:philKV8erP02ggjk2mRIdvJd2ZjMzpmqu0+zwwzKmNw=
+github.com/ethereum-optimism/optimism/op-bindings v0.10.5 h1:CcVHlC1QW3z6X/GYhwRfx7gz3WWho6hnVObzuNDLUS4=
+github.com/ethereum-optimism/optimism/op-bindings v0.10.5/go.mod h1:9ZSUq/rjlzp3uYyBN4sZmhTc3oZgDVqJ4wrUja7vj6c=
 github.com/ethereum-optimism/optimism/op-node v0.10.1 h1:kVBaOEOYLV22XEHRhB7dfdmoXepO0kx/RsZQK+Bpk1Y=
 github.com/ethereum-optimism/optimism/op-node v0.10.1/go.mod h1:pup7wiiUs9g8cZKwXeB5tEGCqwUUwFVmej9MmSIm6S8=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=

op-e2e/actions/l1_replica.go

@@ -169,7 +169,7 @@ func (s *L1Replica) RPCClient() client.RPC {
 }
 
 func (s *L1Replica) L1Client(t Testing, cfg *rollup.Config) *sources.L1Client {
-	l1F, err := sources.NewL1Client(s.RPCClient(), s.log, nil, sources.L1ClientDefaultConfig(cfg, false))
+	l1F, err := sources.NewL1Client(s.RPCClient(), s.log, nil, sources.L1ClientDefaultConfig(cfg, false, sources.RPCKindBasic))
 	require.NoError(t, err)
 	return l1F
 }

op-e2e/actions/l1_replica_test.go

@@ -39,7 +39,7 @@ func TestL1Replica_ActL1RPCFail(gt *testing.T) {
 	// mock an RPC failure
 	replica.ActL1RPCFail(t)
 	// check RPC failure
-	l1Cl, err := sources.NewL1Client(replica.RPCClient(), log, nil, sources.L1ClientDefaultConfig(sd.RollupCfg, false))
+	l1Cl, err := sources.NewL1Client(replica.RPCClient(), log, nil, sources.L1ClientDefaultConfig(sd.RollupCfg, false, sources.RPCKindBasic))
 	require.NoError(t, err)
 	_, err = l1Cl.InfoByLabel(t.Ctx(), eth.Unsafe)
 	require.ErrorContains(t, err, "mock")

op-e2e/actions/l2_sequencer_test.go

@@ -21,7 +21,7 @@ func setupSequencerTest(t Testing, sd *e2eutils.SetupData, log log.Logger) (*L1M
 
 	miner := NewL1Miner(t, log, sd.L1Cfg)
 
-	l1F, err := sources.NewL1Client(miner.RPCClient(), log, nil, sources.L1ClientDefaultConfig(sd.RollupCfg, false))
+	l1F, err := sources.NewL1Client(miner.RPCClient(), log, nil, sources.L1ClientDefaultConfig(sd.RollupCfg, false, sources.RPCKindBasic))
 	require.NoError(t, err)
 	engine := NewL2Engine(t, log, sd.L2Cfg, sd.RollupCfg.Genesis.L1, jwtPath)
 	l2Cl, err := sources.NewEngineClient(engine.RPCClient(), log, nil, sources.EngineClientDefaultConfig(sd.RollupCfg))

op-e2e/actions/reorg_test.go

@@ -285,7 +285,7 @@ func TestRestartOpGeth(gt *testing.T) {
 	jwtPath := e2eutils.WriteDefaultJWT(t)
 	// L1
 	miner := NewL1Miner(t, log, sd.L1Cfg)
-	l1F, err := sources.NewL1Client(miner.RPCClient(), log, nil, sources.L1ClientDefaultConfig(sd.RollupCfg, false))
+	l1F, err := sources.NewL1Client(miner.RPCClient(), log, nil, sources.L1ClientDefaultConfig(sd.RollupCfg, false, sources.RPCKindBasic))
 	require.NoError(t, err)
 	// Sequencer
 	seqEng := NewL2Engine(t, log, sd.L2Cfg, sd.RollupCfg.Genesis.L1, jwtPath, dbOption)
@@ -380,7 +380,7 @@ func TestConflictingL2Blocks(gt *testing.T) {
 	altSeqEng := NewL2Engine(t, log, sd.L2Cfg, sd.RollupCfg.Genesis.L1, jwtPath)
 	altSeqEngCl, err := sources.NewEngineClient(altSeqEng.RPCClient(), log, nil, sources.EngineClientDefaultConfig(sd.RollupCfg))
 	require.NoError(t, err)
-	l1F, err := sources.NewL1Client(miner.RPCClient(), log, nil, sources.L1ClientDefaultConfig(sd.RollupCfg, false))
+	l1F, err := sources.NewL1Client(miner.RPCClient(), log, nil, sources.L1ClientDefaultConfig(sd.RollupCfg, false, sources.RPCKindBasic))
 	require.NoError(t, err)
 	altSequencer := NewL2Sequencer(t, log, l1F, altSeqEngCl, sd.RollupCfg, 0)
 	altBatcher := NewL2Batcher(log, sd.RollupCfg, &BatcherCfg{

op-e2e/go.mod

@@ -11,11 +11,11 @@ require (
 	github.com/docker/go-connections v0.4.0
 	github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3
 	github.com/ethereum-optimism/optimism/op-batcher v0.10.4
-	github.com/ethereum-optimism/optimism/op-bindings v0.10.4
-	github.com/ethereum-optimism/optimism/op-chain-ops v0.10.4
-	github.com/ethereum-optimism/optimism/op-node v0.10.4
-	github.com/ethereum-optimism/optimism/op-proposer v0.10.4
-	github.com/ethereum-optimism/optimism/op-service v0.10.4
+	github.com/ethereum-optimism/optimism/op-bindings v0.10.5
+	github.com/ethereum-optimism/optimism/op-chain-ops v0.10.5
+	github.com/ethereum-optimism/optimism/op-node v0.10.5
+	github.com/ethereum-optimism/optimism/op-proposer v0.10.5
+	github.com/ethereum-optimism/optimism/op-service v0.10.5
 	github.com/ethereum/go-ethereum v1.10.26
 	github.com/google/gofuzz v1.2.1-0.20220503160820-4a35382e8fc8
 	github.com/libp2p/go-libp2p v0.23.3

op-e2e/go.sum

@@ -159,14 +159,16 @@ github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3 h1:RWHKLhCrQThMfch+QJ1Z
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3/go.mod h1:QziizLAiF0KqyLdNJYD7O5cpDlaFMNZzlxYNcWsJUxs=
 github.com/ethereum-optimism/op-geth v0.0.0-20221216190603-60b51d600468 h1:7KgjBYDji5AKi42eRYI+n8Gs+ZJVilSASL3WBu82c3M=
 github.com/ethereum-optimism/op-geth v0.0.0-20221216190603-60b51d600468/go.mod h1:p0Yox74PhYlq1HvijrCBCD9A3cI7rXco7hT6KrQr+rY=
-github.com/ethereum-optimism/optimism/op-bindings v0.10.4 h1:CFn4+t0FUrBG5DmkKyYrLbGmzHWLdLv8QdUnlklvozc=
-github.com/ethereum-optimism/optimism/op-bindings v0.10.4/go.mod h1:philKV8erP02ggjk2mRIdvJd2ZjMzpmqu0+zwwzKmNw=
-github.com/ethereum-optimism/optimism/op-chain-ops v0.10.4 h1:10/BrNfcobBNuaIQQAUcDblzLCtNeGMhGvqHdzhENKk=
-github.com/ethereum-optimism/optimism/op-chain-ops v0.10.4/go.mod h1:AIajN/ydQj57npQeqP0hcax3lhjix5brpEgw0KpvI/A=
-github.com/ethereum-optimism/optimism/op-node v0.10.4 h1:ZXqfrFKgb6W4ZLbkfO9NlgaQ1djBCCPzNGbd6TgehVI=
-github.com/ethereum-optimism/optimism/op-node v0.10.4/go.mod h1:avOLjMLxzB5QB7HmiLlpNkyS93QVHdr0AttRdfYGX3Y=
-github.com/ethereum-optimism/optimism/op-service v0.10.4 h1:WKqNyOBkdJ0ZdlGiDPROZMaWfYxpsYjA5Anb0Bkl5m4=
-github.com/ethereum-optimism/optimism/op-service v0.10.4/go.mod h1:7INvNCJGwVgNT4gz9Yupx7PAEJeu+F/JtHKv1fOr+9Q=
+github.com/ethereum-optimism/optimism/op-bindings v0.10.5 h1:CcVHlC1QW3z6X/GYhwRfx7gz3WWho6hnVObzuNDLUS4=
+github.com/ethereum-optimism/optimism/op-bindings v0.10.5/go.mod h1:9ZSUq/rjlzp3uYyBN4sZmhTc3oZgDVqJ4wrUja7vj6c=
+github.com/ethereum-optimism/optimism/op-chain-ops v0.10.5 h1:yhuVugYcMfpc71EWLM5YeO8ONzZY7AGiYAbzE3rQZIo=
+github.com/ethereum-optimism/optimism/op-chain-ops v0.10.5/go.mod h1:zTZRVhF64yYU7WrTDNqghkE+5Nw1nxnRnrzGS1wRhvQ=
+github.com/ethereum-optimism/optimism/op-node v0.10.5 h1:Fp9xzbcfqGQEicpbrcWKED2uqZOSZscID7aN56KDTok=
+github.com/ethereum-optimism/optimism/op-node v0.10.5/go.mod h1:GPsNceaHhDJZcxH7CsdJYuqAqUuE9xz69MzO7Qu6doo=
+github.com/ethereum-optimism/optimism/op-proposer v0.10.5 h1:bpw3D3yVg1XLDy5VC5KKWvGYa3zDsat9GLxXCs4dNQE=
+github.com/ethereum-optimism/optimism/op-proposer v0.10.5/go.mod h1:6zXmBmtwdvvzVeWoQmgR5bPn/VHOm8Vh8y8LVxjsneo=
+github.com/ethereum-optimism/optimism/op-service v0.10.5 h1:N0hG156WHOP0C60rkN0JI8hWkmKW5LvR4pppSgJiU4M=
+github.com/ethereum-optimism/optimism/op-service v0.10.5/go.mod h1:wbtHqi1fv00B3agj7a2zdP3OFanEfGZ23zPgGgFCF/c=
 github.com/fjl/memsize v0.0.1 h1:+zhkb+dhUgx0/e+M8sF0QqiouvMQUiKR+QYvdxIOKcQ=
 github.com/fjl/memsize v0.0.1/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/flynn/noise v1.0.0 h1:DlTHqmzmvcEiKj+4RYo/imoswx/4r6iBlCMfVtrMXpQ=

op-e2e/migration_test.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	bss "github.com/ethereum-optimism/optimism/op-batcher/batcher"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
 	l2os "github.com/ethereum-optimism/optimism/op-proposer/proposer"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 
@@ -268,6 +269,7 @@ func TestMigration(t *testing.T) {
 		L1: &node.L1EndpointConfig{
 			L1NodeAddr: forkedL1URL,
 			L1TrustRPC: false,
+			L1RPCKind:  sources.RPCKindBasic,
 		},
 		L2: &node.L2EndpointConfig{
 			L2EngineAddr:      gethNode.HTTPAuthEndpoint(),

op-e2e/setup.go

@@ -32,6 +32,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/p2p"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/driver"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	l2os "github.com/ethereum-optimism/optimism/op-proposer/proposer"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
@@ -368,6 +369,7 @@ func (cfg SystemConfig) Start() (*System, error) {
 		rollupCfg.L1 = &rollupNode.L1EndpointConfig{
 			L1NodeAddr: l1EndpointConfig,
 			L1TrustRPC: false,
+			L1RPCKind:  sources.RPCKindBasic,
 		}
 		rollupCfg.L2 = &rollupNode.L2EndpointConfig{
 			L2EngineAddr:      l2EndpointConfig,

op-node/eth/types.go

@@ -2,9 +2,7 @@ package eth
 
 import (
 	"bytes"
-	"context"
 	"fmt"
-	"io"
 	"math/big"
 	"reflect"
 
@@ -281,42 +279,6 @@ type ForkchoiceUpdatedResult struct {
 	PayloadID *PayloadID `json:"payloadId"`
 }
 
-// ReceiptsFetcher fetches receipts of a block,
-// and enables the caller to parallelize fetching and backoff on fetching errors as needed.
-type ReceiptsFetcher interface {
-	// Reset clears the previously fetched results for a fresh re-attempt.
-	Reset()
-	// Fetch retrieves receipts in batches, until it returns io.EOF to indicate completion.
-	Fetch(ctx context.Context) error
-	// Complete indicates when all data has been fetched.
-	Complete() bool
-	// Result returns the receipts, or an error if the Fetch-ing is not Complete,
-	// or an error if the results are invalid.
-	// If an error is returned, the fetcher is Reset automatically.
-	Result() (types.Receipts, error)
-}
-
-// FetchedReceipts is a simple util to implement the ReceiptsFetcher with readily available receipts.
-type FetchedReceipts types.Receipts
-
-func (f FetchedReceipts) Reset() {
-	// nothing to reset
-}
-
-func (f FetchedReceipts) Fetch(ctx context.Context) error {
-	return io.EOF
-}
-
-func (f FetchedReceipts) Complete() bool {
-	return true
-}
-
-func (f FetchedReceipts) Result() (types.Receipts, error) {
-	return types.Receipts(f), nil
-}
-
-var _ ReceiptsFetcher = (FetchedReceipts)(nil)
-
 // SystemConfig represents the rollup system configuration that carries over in every L2 block,
 // and may be changed through L1 system config events.
 // The initial SystemConfig at rollup genesis is embedded in the rollup configuration.

op-node/flags/flags.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
 
 	"github.com/urfave/cli"
 )
@@ -63,6 +64,16 @@ var (
 		Usage:  "Trust the L1 RPC, sync faster at risk of malicious/buggy RPC providing bad or inconsistent L1 data",
 		EnvVar: prefixEnvVar("L1_TRUST_RPC"),
 	}
+	L1RPCProviderKind = cli.GenericFlag{
+		Name: "l1.rpckind",
+		Usage: "The kind of RPC provider, used to inform optimal transactions receipts fetching, and thus reduce costs. Valid options: " +
+			EnumString[sources.RPCProviderKind](sources.RPCProviderKinds),
+		EnvVar: prefixEnvVar("L1_RPC_KIND"),
+		Value: func() *sources.RPCProviderKind {
+			out := sources.RPCKindBasic
+			return &out
+		}(),
+	}
 	L2EngineJWTSecret = cli.StringFlag{
 		Name:        "l2.jwt-secret",
 		Usage:       "Path to JWT secret key. Keys are 32 bytes, hex encoded in a file. A new key will be generated if left empty.",
@@ -182,6 +193,7 @@ var optionalFlags = append([]cli.Flag{
 	RollupConfig,
 	Network,
 	L1TrustRPC,
+	L1RPCProviderKind,
 	L2EngineJWTSecret,
 	VerifierL1Confs,
 	SequencerEnabledFlag,

op-node/flags/util.go

+package flags
+
+import (
+	"fmt"
+	"strings"
+)
+
+func EnumString[T fmt.Stringer](values []T) string {
+	var out strings.Builder
+	for i, v := range values {
+		out.WriteString(v.String())
+		if i+1 < len(values) {
+			out.WriteString(", ")
+		}
+	}
+	return out.String()
+}

op-node/go.mod

@@ -6,9 +6,9 @@ require (
 	github.com/btcsuite/btcd v0.23.3
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0
-	github.com/ethereum-optimism/optimism/op-bindings v0.10.4
-	github.com/ethereum-optimism/optimism/op-chain-ops v0.10.4
-	github.com/ethereum-optimism/optimism/op-service v0.10.4
+	github.com/ethereum-optimism/optimism/op-bindings v0.10.5
+	github.com/ethereum-optimism/optimism/op-chain-ops v0.10.5
+	github.com/ethereum-optimism/optimism/op-service v0.10.5
 	github.com/ethereum/go-ethereum v1.10.26
 	github.com/golang/snappy v0.0.4
 	github.com/google/go-cmp v0.5.8

op-node/go.sum

@@ -145,12 +145,12 @@ github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1m
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/ethereum-optimism/op-geth v0.0.0-20221216190603-60b51d600468 h1:7KgjBYDji5AKi42eRYI+n8Gs+ZJVilSASL3WBu82c3M=
 github.com/ethereum-optimism/op-geth v0.0.0-20221216190603-60b51d600468/go.mod h1:p0Yox74PhYlq1HvijrCBCD9A3cI7rXco7hT6KrQr+rY=
-github.com/ethereum-optimism/optimism/op-bindings v0.10.4 h1:CFn4+t0FUrBG5DmkKyYrLbGmzHWLdLv8QdUnlklvozc=
-github.com/ethereum-optimism/optimism/op-bindings v0.10.4/go.mod h1:philKV8erP02ggjk2mRIdvJd2ZjMzpmqu0+zwwzKmNw=
-github.com/ethereum-optimism/optimism/op-chain-ops v0.10.4 h1:10/BrNfcobBNuaIQQAUcDblzLCtNeGMhGvqHdzhENKk=
-github.com/ethereum-optimism/optimism/op-chain-ops v0.10.4/go.mod h1:AIajN/ydQj57npQeqP0hcax3lhjix5brpEgw0KpvI/A=
-github.com/ethereum-optimism/optimism/op-service v0.10.4 h1:WKqNyOBkdJ0ZdlGiDPROZMaWfYxpsYjA5Anb0Bkl5m4=
-github.com/ethereum-optimism/optimism/op-service v0.10.4/go.mod h1:7INvNCJGwVgNT4gz9Yupx7PAEJeu+F/JtHKv1fOr+9Q=
+github.com/ethereum-optimism/optimism/op-bindings v0.10.5 h1:CcVHlC1QW3z6X/GYhwRfx7gz3WWho6hnVObzuNDLUS4=
+github.com/ethereum-optimism/optimism/op-bindings v0.10.5/go.mod h1:9ZSUq/rjlzp3uYyBN4sZmhTc3oZgDVqJ4wrUja7vj6c=
+github.com/ethereum-optimism/optimism/op-chain-ops v0.10.5 h1:yhuVugYcMfpc71EWLM5YeO8ONzZY7AGiYAbzE3rQZIo=
+github.com/ethereum-optimism/optimism/op-chain-ops v0.10.5/go.mod h1:zTZRVhF64yYU7WrTDNqghkE+5Nw1nxnRnrzGS1wRhvQ=
+github.com/ethereum-optimism/optimism/op-service v0.10.5 h1:N0hG156WHOP0C60rkN0JI8hWkmKW5LvR4pppSgJiU4M=
+github.com/ethereum-optimism/optimism/op-service v0.10.5/go.mod h1:wbtHqi1fv00B3agj7a2zdP3OFanEfGZ23zPgGgFCF/c=
 github.com/fjl/memsize v0.0.1 h1:+zhkb+dhUgx0/e+M8sF0QqiouvMQUiKR+QYvdxIOKcQ=
 github.com/fjl/memsize v0.0.1/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=

op-node/node/client.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 
 	"github.com/ethereum-optimism/optimism/op-node/client"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
+
 	"github.com/ethereum/go-ethereum/log"
 	gn "github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rpc"
@@ -19,7 +21,9 @@ type L2EndpointSetup interface {
 
 type L1EndpointSetup interface {
 	// Setup a RPC client to a L1 node to pull rollup input-data from.
-	Setup(ctx context.Context, log log.Logger) (cl client.RPC, trust bool, err error)
+	// The results of the RPC client may be trusted for faster processing, or strictly validated.
+	// The kind of the RPC may be non-basic, to optimize RPC usage.
+	Setup(ctx context.Context, log log.Logger) (cl client.RPC, trust bool, kind sources.RPCProviderKind, err error)
 }
 
 type L2EndpointConfig struct {
@@ -78,26 +82,31 @@ type L1EndpointConfig struct {
 	// against block hashes, or cached transaction sender addresses.
 	// Thus we can sync faster at the risk of the source RPC being wrong.
 	L1TrustRPC bool
+
+	// L1RPCKind identifies the RPC provider kind that serves the RPC,
+	// to inform the optimal usage of the RPC for transaction receipts fetching.
+	L1RPCKind sources.RPCProviderKind
 }
 
 var _ L1EndpointSetup = (*L1EndpointConfig)(nil)
 
-func (cfg *L1EndpointConfig) Setup(ctx context.Context, log log.Logger) (cl client.RPC, trust bool, err error) {
+func (cfg *L1EndpointConfig) Setup(ctx context.Context, log log.Logger) (cl client.RPC, trust bool, kind sources.RPCProviderKind, err error) {
 	l1Node, err := client.NewRPC(ctx, log, cfg.L1NodeAddr)
 	if err != nil {
-		return nil, false, fmt.Errorf("failed to dial L1 address (%s): %w", cfg.L1NodeAddr, err)
+		return nil, false, sources.RPCKindBasic, fmt.Errorf("failed to dial L1 address (%s): %w", cfg.L1NodeAddr, err)
 	}
-	return l1Node, cfg.L1TrustRPC, nil
+	return l1Node, cfg.L1TrustRPC, cfg.L1RPCKind, nil
 }
 
 // PreparedL1Endpoint enables testing with an in-process pre-setup RPC connection to L1
 type PreparedL1Endpoint struct {
-	Client   client.RPC
-	TrustRPC bool
+	Client          client.RPC
+	TrustRPC        bool
+	RPCProviderKind sources.RPCProviderKind
 }
 
 var _ L1EndpointSetup = (*PreparedL1Endpoint)(nil)
 
-func (p *PreparedL1Endpoint) Setup(ctx context.Context, log log.Logger) (cl client.RPC, trust bool, err error) {
-	return p.Client, p.TrustRPC, nil
+func (p *PreparedL1Endpoint) Setup(ctx context.Context, log log.Logger) (cl client.RPC, trust bool, kind sources.RPCProviderKind, err error) {
+	return p.Client, p.TrustRPC, p.RPCProviderKind, nil
 }

op-node/node/node.go

@@ -112,14 +112,14 @@ func (n *OpNode) initTracer(ctx context.Context, cfg *Config) error {
 }
 
 func (n *OpNode) initL1(ctx context.Context, cfg *Config) error {
-	l1Node, trustRPC, err := cfg.L1.Setup(ctx, n.log)
+	l1Node, trustRPC, rpcProvKind, err := cfg.L1.Setup(ctx, n.log)
 	if err != nil {
 		return fmt.Errorf("failed to get L1 RPC client: %w", err)
 	}
 
 	n.l1Source, err = sources.NewL1Client(
 		client.NewInstrumentedRPC(l1Node, n.metrics), n.log, n.metrics.L1SourceCache,
-		sources.L1ClientDefaultConfig(&cfg.Rollup, trustRPC))
+		sources.L1ClientDefaultConfig(&cfg.Rollup, trustRPC, rpcProvKind))
 	if err != nil {
 		return fmt.Errorf("failed to create L1 source: %w", err)
 	}

op-node/service.go

@@ -9,17 +9,19 @@ import (
 	"strings"
 
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
 
 	"github.com/urfave/cli"
 
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/log"
+
 	"github.com/ethereum-optimism/optimism/op-node/flags"
 	"github.com/ethereum-optimism/optimism/op-node/node"
 	"github.com/ethereum-optimism/optimism/op-node/p2p"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/driver"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/log"
 )
 
 // NewConfig creates a Config from the provided flags or environment variables.
@@ -97,6 +99,7 @@ func NewL1EndpointConfig(ctx *cli.Context) (*node.L1EndpointConfig, error) {
 	return &node.L1EndpointConfig{
 		L1NodeAddr: ctx.GlobalString(flags.L1NodeAddr.Name),
 		L1TrustRPC: ctx.GlobalBool(flags.L1TrustRPC.Name),
+		L1RPCKind:  sources.RPCProviderKind(strings.ToLower(ctx.GlobalString(flags.L1RPCProviderKind.Name))),
 	}, nil
 }
 

op-node/sources/batching.go

@@ -15,7 +15,7 @@ import (
 // IterativeBatchCall is an util to create a job to fetch many RPC requests in batches,
 // and enable the caller to parallelize easily and safely, handle and re-try errors,
 // and pick a batch size all by simply calling Fetch again and again until it returns io.EOF.
-type IterativeBatchCall[K any, V any, O any] struct {
+type IterativeBatchCall[K any, V any] struct {
 	completed uint32       // tracks how far to completing all requests we are
 	resetLock sync.RWMutex // ensures we do not concurrently read (incl. fetch) / reset
 
@@ -23,23 +23,19 @@ type IterativeBatchCall[K any, V any, O any] struct {
 	batchSize    int
 
 	makeRequest func(K) (V, rpc.BatchElem)
-	makeResults func([]K, []V) (O, error)
 	getBatch    BatchCallContextFn
 
 	requestsValues []V
 	scheduled      chan rpc.BatchElem
-
-	results *O
 }
 
 // NewIterativeBatchCall constructs a batch call, fetching the values with the given keys,
 // and transforms them into a verified final result.
-func NewIterativeBatchCall[K any, V any, O any](
+func NewIterativeBatchCall[K any, V any](
 	requestsKeys []K,
 	makeRequest func(K) (V, rpc.BatchElem),
-	makeResults func([]K, []V) (O, error),
 	getBatch BatchCallContextFn,
-	batchSize int) *IterativeBatchCall[K, V, O] {
+	batchSize int) *IterativeBatchCall[K, V] {
 
 	if len(requestsKeys) < batchSize {
 		batchSize = len(requestsKeys)
@@ -48,20 +44,19 @@ func NewIterativeBatchCall[K any, V any, O any](
 		batchSize = 1
 	}
 
-	out := &IterativeBatchCall[K, V, O]{
+	out := &IterativeBatchCall[K, V]{
 		completed:    0,
 		getBatch:     getBatch,
 		requestsKeys: requestsKeys,
 		batchSize:    batchSize,
 		makeRequest:  makeRequest,
-		makeResults:  makeResults,
 	}
 	out.Reset()
 	return out
 }
 
 // Reset will clear the batch call, to start fetching all contents from scratch.
-func (ibc *IterativeBatchCall[K, V, O]) Reset() {
+func (ibc *IterativeBatchCall[K, V]) Reset() {
 	ibc.resetLock.Lock()
 	defer ibc.resetLock.Unlock()
 
@@ -85,7 +80,7 @@ func (ibc *IterativeBatchCall[K, V, O]) Reset() {
 // This method is safe to call concurrently: it will parallelize the fetching work.
 // If no work is available, but the fetching is not done yet,
 // then Fetch will block until the next thing can be fetched, or until the context expires.
-func (ibc *IterativeBatchCall[K, V, O]) Fetch(ctx context.Context) error {
+func (ibc *IterativeBatchCall[K, V]) Fetch(ctx context.Context) error {
 	ibc.resetLock.RLock()
 	defer ibc.resetLock.RUnlock()
 
@@ -150,7 +145,7 @@ func (ibc *IterativeBatchCall[K, V, O]) Fetch(ctx context.Context) error {
 }
 
 // Complete indicates if the batch call is done.
-func (ibc *IterativeBatchCall[K, V, O]) Complete() bool {
+func (ibc *IterativeBatchCall[K, V]) Complete() bool {
 	ibc.resetLock.RLock()
 	defer ibc.resetLock.RUnlock()
 	return atomic.LoadUint32(&ibc.completed) >= uint32(len(ibc.requestsKeys))
@@ -158,27 +153,12 @@ func (ibc *IterativeBatchCall[K, V, O]) Complete() bool {
 
 // Result returns the fetched values, checked and transformed to the final output type, if available.
 // If the check fails, the IterativeBatchCall will Reset itself, to be ready for a re-attempt in fetching new data.
-func (ibc *IterativeBatchCall[K, V, O]) Result() (O, error) {
+func (ibc *IterativeBatchCall[K, V]) Result() ([]V, error) {
 	ibc.resetLock.RLock()
 	if atomic.LoadUint32(&ibc.completed) < uint32(len(ibc.requestsKeys)) {
 		ibc.resetLock.RUnlock()
-		return *new(O), fmt.Errorf("results not available yet, Fetch more first")
-	}
-	if ibc.results != nil {
-		ibc.resetLock.RUnlock()
-		return *ibc.results, nil
+		return nil, fmt.Errorf("results not available yet, Fetch more first")
 	}
-	out, err := ibc.makeResults(ibc.requestsKeys, ibc.requestsValues)
 	ibc.resetLock.RUnlock()
-	if err != nil {
-		// start over
-		ibc.Reset()
-	} else {
-		// cache the valid results
-		ibc.resetLock.Lock()
-		ibc.results = &out
-		ibc.resetLock.Unlock()
-	}
-
-	return out, err
+	return ibc.requestsValues, nil
 }

op-node/sources/batching_test.go

@@ -49,12 +49,6 @@ func makeTestRequest(i int) (*string, rpc.BatchElem) {
 	}
 }
 
-func makeTestResults() func(keys []int, values []*string) ([]*string, error) {
-	return func(keys []int, values []*string) ([]*string, error) {
-		return values, nil
-	}
-}
-
 func (tc *batchTestCase) GetBatch(ctx context.Context, b []rpc.BatchElem) error {
 	if ctx.Err() != nil {
 		return ctx.Err()
@@ -103,7 +97,7 @@ func (tc *batchTestCase) Run(t *testing.T) {
 			tc.On("get", batch).Once().Run(makeMock(bci, bc)).Return([]error{bc.rpcErr}) // wrap to preserve nil as type of error
 		}
 	}
-	iter := NewIterativeBatchCall[int, *string, []*string](keys, makeTestRequest, makeTestResults(), tc.GetBatch, tc.batchSize)
+	iter := NewIterativeBatchCall[int, *string](keys, makeTestRequest, tc.GetBatch, tc.batchSize)
 	for i, bc := range tc.batchCalls {
 		ctx := context.Background()
 		if bc.makeCtx != nil {

op-node/sources/eth_client.go

@@ -3,7 +3,6 @@ package sources
 import (
 	"context"
 	"fmt"
-	"io"
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
@@ -44,6 +43,9 @@ type EthClientConfig struct {
 	// If this is not checked, disabled header fields like the nonce or difficulty
 	// may be used to get a different block-hash.
 	MustBePostMerge bool
+
+	// RPCProviderKind is a hint at what type of RPC provider we are dealing with
+	RPCProviderKind RPCProviderKind
 }
 
 func (c *EthClientConfig) Check() error {
@@ -65,6 +67,9 @@ func (c *EthClientConfig) Check() error {
 	if c.MaxRequestsPerBatch < 1 {
 		return fmt.Errorf("expected at least 1 request per batch, but max is: %d", c.MaxRequestsPerBatch)
 	}
+	if !ValidRPCProviderKind(c.RPCProviderKind) {
+		return fmt.Errorf("unknown rpc provider kind: %s", c.RPCProviderKind)
+	}
 	return nil
 }
 
@@ -78,11 +83,13 @@ type EthClient struct {
 
 	mustBePostMerge bool
 
+	provKind RPCProviderKind
+
 	log log.Logger
 
 	// cache receipts in bundles per block hash
-	// We cache the receipts fetcher to not lose progress when we have to retry the `Fetch` call
-	// common.Hash -> eth.ReceiptsFetcher
+	// We cache the receipts fetching job to not lose progress when we have to retry the `Fetch` call
+	// common.Hash -> *receiptsFetchingJob
 	receiptsCache *caching.LRUCache
 
 	// cache transactions in bundles per block hash
@@ -96,6 +103,27 @@ type EthClient struct {
 	// cache payloads by hash
 	// common.Hash -> *eth.ExecutionPayload
 	payloadsCache *caching.LRUCache
+
+	// availableReceiptMethods tracks which receipt methods can be used for fetching receipts
+	// This may be modified concurrently, but we don't lock since it's a single
+	// uint64 that's not critical (fine to miss or mix up a modification)
+	availableReceiptMethods ReceiptsFetchingMethod
+}
+
+func (s *EthClient) PickReceiptsMethod(txCount uint64) ReceiptsFetchingMethod {
+	return PickBestReceiptsFetchingMethod(s.provKind, s.availableReceiptMethods, txCount)
+}
+
+func (s *EthClient) OnReceiptsMethodErr(m ReceiptsFetchingMethod, err error) {
+	if unusableMethod(err) {
+		// clear the bit of the method that errored
+		s.availableReceiptMethods &^= m
+		s.log.Warn("failed to use selected RPC method for receipt fetching, falling back to alternatives",
+			"provider_kind", s.provKind, "failed_method", m, "fallback", s.availableReceiptMethods, "err", err)
+	} else {
+		s.log.Debug("failed to use selected RPC method for receipt fetching, but method does appear to be available, so we continue to use it",
+			"provider_kind", s.provKind, "failed_method", m, "fallback", s.availableReceiptMethods&^m, "err", err)
+	}
 }
 
 // NewEthClient wraps a RPC with bindings to fetch ethereum data,
@@ -106,14 +134,17 @@ func NewEthClient(client client.RPC, log log.Logger, metrics caching.Metrics, co
 	}
 	client = LimitRPC(client, config.MaxConcurrentRequests)
 	return &EthClient{
-		client:            client,
-		maxBatchSize:      config.MaxRequestsPerBatch,
-		trustRPC:          config.TrustRPC,
-		log:               log,
-		receiptsCache:     caching.NewLRUCache(metrics, "receipts", config.ReceiptsCacheSize),
-		transactionsCache: caching.NewLRUCache(metrics, "txs", config.TransactionsCacheSize),
-		headersCache:      caching.NewLRUCache(metrics, "headers", config.HeadersCacheSize),
-		payloadsCache:     caching.NewLRUCache(metrics, "payloads", config.PayloadsCacheSize),
+		client:                  client,
+		maxBatchSize:            config.MaxRequestsPerBatch,
+		trustRPC:                config.TrustRPC,
+		mustBePostMerge:         config.MustBePostMerge,
+		provKind:                config.RPCProviderKind,
+		log:                     log,
+		receiptsCache:           caching.NewLRUCache(metrics, "receipts", config.ReceiptsCacheSize),
+		transactionsCache:       caching.NewLRUCache(metrics, "txs", config.TransactionsCacheSize),
+		headersCache:            caching.NewLRUCache(metrics, "headers", config.HeadersCacheSize),
+		payloadsCache:           caching.NewLRUCache(metrics, "payloads", config.PayloadsCacheSize),
+		availableReceiptMethods: AvailableReceiptsFetchingMethods(config.RPCProviderKind),
 	}, nil
 }
 
@@ -238,26 +269,18 @@ func (s *EthClient) FetchReceipts(ctx context.Context, blockHash common.Hash) (e
 	// Try to reuse the receipts fetcher because is caches the results of intermediate calls. This means
 	// that if just one of many calls fail, we only retry the failed call rather than all of the calls.
 	// The underlying fetcher uses the receipts hash to verify receipt integrity.
-	var fetcher eth.ReceiptsFetcher
+	var job *receiptsFetchingJob
 	if v, ok := s.receiptsCache.Get(blockHash); ok {
-		fetcher = v.(eth.ReceiptsFetcher)
+		job = v.(*receiptsFetchingJob)
 	} else {
 		txHashes := make([]common.Hash, len(txs))
 		for i := 0; i < len(txs); i++ {
 			txHashes[i] = txs[i].Hash()
 		}
-		fetcher = NewReceiptsFetcher(eth.ToBlockID(info), info.ReceiptHash(), txHashes, s.client.BatchCallContext, s.maxBatchSize)
-		s.receiptsCache.Add(blockHash, fetcher)
-	}
-	// Fetch all receipts
-	for {
-		if err := fetcher.Fetch(ctx); err == io.EOF {
-			break
-		} else if err != nil {
-			return nil, nil, err
-		}
+		job = NewReceiptsFetchingJob(s, s.client, s.maxBatchSize, eth.ToBlockID(info), info.ReceiptHash(), txHashes)
+		s.receiptsCache.Add(blockHash, job)
 	}
-	receipts, err := fetcher.Result()
+	receipts, err := job.Fetch(ctx)
 	if err != nil {
 		return nil, nil, err
 	}

op-node/sources/eth_client_test.go

@@ -52,6 +52,7 @@ var testEthClientConfig = &EthClientConfig{
 	MaxConcurrentRequests: 10,
 	TrustRPC:              false,
 	MustBePostMerge:       false,
+	RPCProviderKind:       RPCKindBasic,
 }
 
 func randHash() (out common.Hash) {
@@ -132,7 +133,7 @@ func TestEthClient_InfoByNumber(t *testing.T) {
 		"eth_getBlockByNumber", []any{n.String(), false}).Run(func(args mock.Arguments) {
 		*args[1].(**rpcHeader) = rhdr
 	}).Return([]error{nil})
-	s, err := NewL1Client(m, nil, nil, L1ClientDefaultConfig(&rollup.Config{SeqWindowSize: 10}, true))
+	s, err := NewL1Client(m, nil, nil, L1ClientDefaultConfig(&rollup.Config{SeqWindowSize: 10}, true, RPCKindBasic))
 	require.NoError(t, err)
 	info, err := s.InfoByNumber(ctx, uint64(n))
 	require.NoError(t, err)

op-node/sources/l1_client.go

@@ -5,13 +5,14 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+
 	"github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/sources/caching"
-	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
 )
 
 type L1ClientConfig struct {
@@ -20,7 +21,7 @@ type L1ClientConfig struct {
 	L1BlockRefsCacheSize int
 }
 
-func L1ClientDefaultConfig(config *rollup.Config, trustRPC bool) *L1ClientConfig {
+func L1ClientDefaultConfig(config *rollup.Config, trustRPC bool, kind RPCProviderKind) *L1ClientConfig {
 	// Cache 3/2 worth of sequencing window of receipts and txs
 	span := int(config.SeqWindowSize) * 3 / 2
 	if span > 1000 { // sanity cap. If a large sequencing window is configured, do not make the cache too large
@@ -37,6 +38,7 @@ func L1ClientDefaultConfig(config *rollup.Config, trustRPC bool) *L1ClientConfig
 			MaxConcurrentRequests: 10,
 			TrustRPC:              trustRPC,
 			MustBePostMerge:       false,
+			RPCProviderKind:       kind,
 		},
 		L1BlockRefsCacheSize: span,
 	}

op-node/sources/l2_client.go

@@ -48,6 +48,7 @@ func L2ClientDefaultConfig(config *rollup.Config, trustRPC bool) *L2ClientConfig
 			MaxConcurrentRequests: 10,
 			TrustRPC:              trustRPC,
 			MustBePostMerge:       true,
+			RPCProviderKind:       RPCKindBasic,
 		},
 		L2BlockRefsCacheSize: span,
 		L1ConfigsCacheSize:   span,

op-node/sources/receipts.go

 package sources
 
 import (
+	"context"
 	"fmt"
+	"io"
+	"math/big"
+	"sync"
 
-	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethereum/go-ethereum/trie"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
 )
 
-func makeReceiptsFn(block eth.BlockID, receiptHash common.Hash) func(txHashes []common.Hash, receipts []*types.Receipt) (types.Receipts, error) {
-	return func(txHashes []common.Hash, receipts []*types.Receipt) (types.Receipts, error) {
-		if len(receipts) != len(txHashes) {
-			return nil, fmt.Errorf("got %d receipts but expected %d", len(receipts), len(txHashes))
+func validateReceipts(block eth.BlockID, receiptHash common.Hash, txHashes []common.Hash, receipts []*types.Receipt) error {
+	if len(receipts) != len(txHashes) {
+		return fmt.Errorf("got %d receipts but expected %d", len(receipts), len(txHashes))
+	}
+	if len(txHashes) == 0 {
+		if receiptHash != types.EmptyRootHash {
+			return fmt.Errorf("no transactions, but got non-empty receipt trie root: %s", receiptHash)
 		}
-		if len(txHashes) == 0 {
-			if receiptHash != types.EmptyRootHash {
-				return nil, fmt.Errorf("no transactions, but got non-empty receipt trie root: %s", receiptHash)
-			}
+	}
+	// We don't trust the RPC to provide consistent cached receipt info that we use for critical rollup derivation work.
+	// Let's check everything quickly.
+	logIndex := uint(0)
+	for i, r := range receipts {
+		if r == nil { // on reorgs or other cases the receipts may disappear before they can be retrieved.
+			return fmt.Errorf("receipt of tx %d returns nil on retrieval", i)
 		}
-		// We don't trust the RPC to provide consistent cached receipt info that we use for critical rollup derivation work.
-		// Let's check everything quickly.
-		logIndex := uint(0)
-		for i, r := range receipts {
-			if r == nil { // on reorgs or other cases the receipts may disappear before they can be retrieved.
-				return nil, fmt.Errorf("receipt of tx %d returns nil on retrieval", i)
+		if r.TransactionIndex != uint(i) {
+			return fmt.Errorf("receipt %d has unexpected tx index %d", i, r.TransactionIndex)
+		}
+		if r.BlockNumber == nil {
+			return fmt.Errorf("receipt %d has unexpected nil block number, expected %d", i, block.Number)
+		}
+		if r.BlockNumber.Uint64() != block.Number {
+			return fmt.Errorf("receipt %d has unexpected block number %d, expected %d", i, r.BlockNumber, block.Number)
+		}
+		if r.BlockHash != block.Hash {
+			return fmt.Errorf("receipt %d has unexpected block hash %s, expected %s", i, r.BlockHash, block.Hash)
+		}
+		for j, log := range r.Logs {
+			if log.Index != logIndex {
+				return fmt.Errorf("log %d (%d of tx %d) has unexpected log index %d", logIndex, j, i, log.Index)
 			}
-			if r.TransactionIndex != uint(i) {
-				return nil, fmt.Errorf("receipt %d has unexpected tx index %d", i, r.TransactionIndex)
+			if log.TxIndex != uint(i) {
+				return fmt.Errorf("log %d has unexpected tx index %d", log.Index, log.TxIndex)
 			}
-			if r.BlockNumber == nil {
-				return nil, fmt.Errorf("receipt %d has unexpected nil block number, expected %d", i, block.Number)
+			if log.BlockHash != block.Hash {
+				return fmt.Errorf("log %d of block %s has unexpected block hash %s", log.Index, block.Hash, log.BlockHash)
 			}
-			if r.BlockNumber.Uint64() != block.Number {
-				return nil, fmt.Errorf("receipt %d has unexpected block number %d, expected %d", i, r.BlockNumber, block.Number)
+			if log.BlockNumber != block.Number {
+				return fmt.Errorf("log %d of block %d has unexpected block number %d", log.Index, block.Number, log.BlockNumber)
 			}
-			if r.BlockHash != block.Hash {
-				return nil, fmt.Errorf("receipt %d has unexpected block hash %s, expected %s", i, r.BlockHash, block.Hash)
+			if log.TxHash != txHashes[i] {
+				return fmt.Errorf("log %d of tx %s has unexpected tx hash %s", log.Index, txHashes[i], log.TxHash)
 			}
-			for j, log := range r.Logs {
-				if log.Index != logIndex {
-					return nil, fmt.Errorf("log %d (%d of tx %d) has unexpected log index %d", logIndex, j, i, log.Index)
-				}
-				if log.TxIndex != uint(i) {
-					return nil, fmt.Errorf("log %d has unexpected tx index %d", log.Index, log.TxIndex)
-				}
-				if log.BlockHash != block.Hash {
-					return nil, fmt.Errorf("log %d of block %s has unexpected block hash %s", log.Index, block.Hash, log.BlockHash)
-				}
-				if log.BlockNumber != block.Number {
-					return nil, fmt.Errorf("log %d of block %d has unexpected block number %d", log.Index, block.Number, log.BlockNumber)
-				}
-				if log.TxHash != txHashes[i] {
-					return nil, fmt.Errorf("log %d of tx %s has unexpected tx hash %s", log.Index, txHashes[i], log.TxHash)
-				}
-				if log.Removed {
-					return nil, fmt.Errorf("canonical log (%d) must never be removed due to reorg", log.Index)
-				}
-				logIndex++
+			if log.Removed {
+				return fmt.Errorf("canonical log (%d) must never be removed due to reorg", log.Index)
 			}
+			logIndex++
 		}
+		// Note: 3 non-consensus L1 receipt fields are ignored:
+		// PostState - not part of L1 ethereum anymore since EIP 658 (part of Byzantium)
+		// ContractAddress - we do not care about contract deployments
+		// GasUsed - we do not care about L1 gas usage of txs
+		// And Optimism L1 fee meta-data in the receipt is ignored as well
+	}
 
-		// Sanity-check: external L1-RPC sources are notorious for not returning all receipts,
-		// or returning them out-of-order. Verify the receipts against the expected receipt-hash.
-		hasher := trie.NewStackTrie(nil)
-		computed := types.DeriveSha(types.Receipts(receipts), hasher)
-		if receiptHash != computed {
-			return nil, fmt.Errorf("failed to fetch list of receipts: expected receipt root %s but computed %s from retrieved receipts", receiptHash, computed)
-		}
-		return receipts, nil
+	// Sanity-check: external L1-RPC sources are notorious for not returning all receipts,
+	// or returning them out-of-order. Verify the receipts against the expected receipt-hash.
+	hasher := trie.NewStackTrie(nil)
+	computed := types.DeriveSha(types.Receipts(receipts), hasher)
+	if receiptHash != computed {
+		return fmt.Errorf("failed to fetch list of receipts: expected receipt root %s but computed %s from retrieved receipts", receiptHash, computed)
 	}
+	return nil
 }
 
 func makeReceiptRequest(txHash common.Hash) (*types.Receipt, rpc.BatchElem) {
@@ -82,13 +91,394 @@ func makeReceiptRequest(txHash common.Hash) (*types.Receipt, rpc.BatchElem) {
 	}
 }
 
-// NewReceiptsFetcher creates a receipt fetcher that can iteratively fetch the receipts matching the given txs.
-func NewReceiptsFetcher(block eth.BlockID, receiptHash common.Hash, txHashes []common.Hash, getBatch BatchCallContextFn, batchSize int) eth.ReceiptsFetcher {
-	return NewIterativeBatchCall[common.Hash, *types.Receipt, types.Receipts](
-		txHashes,
-		makeReceiptRequest,
-		makeReceiptsFn(block, receiptHash),
-		getBatch,
-		batchSize,
-	)
+// Cost break-down sources:
+// Alchemy: https://docs.alchemy.com/reference/compute-units
+// QuickNode: https://www.quicknode.com/docs/ethereum/api_credits
+// Infura: no pricing table available.
+//
+// Receipts are encoded the same everywhere:
+//
+//     blockHash, blockNumber, transactionIndex, transactionHash, from, to, cumulativeGasUsed, gasUsed,
+//     contractAddress, logs, logsBloom, status, effectiveGasPrice, type.
+//
+// Note that Alchemy/Geth still have a "root" field for legacy reasons,
+// but ethereum does not compute state-roots per tx anymore, so quicknode and others do not serve this data.
+
+// RPCProviderKind identifies an RPC provider, used to hint at the optimal receipt fetching approach.
+type RPCProviderKind string
+
+const (
+	RPCKindAlchemy    RPCProviderKind = "alchemy"
+	RPCKindQuickNode  RPCProviderKind = "quicknode"
+	RPCKindInfura     RPCProviderKind = "infura"
+	RPCKindParity     RPCProviderKind = "parity"
+	RPCKindNethermind RPCProviderKind = "nethermind"
+	RPCKindDebugGeth  RPCProviderKind = "debug_geth"
+	RPCKindErigon     RPCProviderKind = "erigon"
+	RPCKindBasic      RPCProviderKind = "basic" // try only the standard most basic receipt fetching
+	RPCKindAny        RPCProviderKind = "any"   // try any method available
+)
+
+var RPCProviderKinds = []RPCProviderKind{
+	RPCKindAlchemy,
+	RPCKindQuickNode,
+	RPCKindInfura,
+	RPCKindParity,
+	RPCKindNethermind,
+	RPCKindDebugGeth,
+	RPCKindErigon,
+	RPCKindBasic,
+	RPCKindAny,
+}
+
+func (kind RPCProviderKind) String() string {
+	return string(kind)
+}
+
+func (kind *RPCProviderKind) Set(value string) error {
+	if !ValidRPCProviderKind(RPCProviderKind(value)) {
+		return fmt.Errorf("unknown rpc kind: %q", value)
+	}
+	*kind = RPCProviderKind(value)
+	return nil
+}
+
+func ValidRPCProviderKind(value RPCProviderKind) bool {
+	for _, k := range RPCProviderKinds {
+		if k == value {
+			return true
+		}
+	}
+	return false
+}
+
+// ReceiptsFetchingMethod is a bitfield with 1 bit for each receipts fetching type.
+// Depending on errors, tx counts and preferences the code may select different sets of fetching methods.
+type ReceiptsFetchingMethod uint64
+
+func (r ReceiptsFetchingMethod) String() string {
+	out := ""
+	x := r
+	addMaybe := func(m ReceiptsFetchingMethod, v string) {
+		if x&m != 0 {
+			out += v
+			x ^= x & m
+		}
+		if x != 0 { // add separator if there are entries left
+			out += ", "
+		}
+	}
+	addMaybe(EthGetTransactionReceiptBatch, "eth_getTransactionReceipt (batched)")
+	addMaybe(AlchemyGetTransactionReceipts, "alchemy_getTransactionReceipts")
+	addMaybe(DebugGetRawReceipts, "debug_getRawReceipts")
+	addMaybe(ParityGetBlockReceipts, "parity_getBlockReceipts")
+	addMaybe(EthGetBlockReceipts, "eth_getBlockReceipts")
+	addMaybe(^ReceiptsFetchingMethod(0), "unknown") // if anything is left, describe it as unknown
+	return out
+}
+
+const (
+	// EthGetTransactionReceiptBatch is standard per-tx receipt fetching with JSON-RPC batches.
+	// Available in: standard, everywhere.
+	//   - Alchemy: 15 CU / tx
+	//   - Quicknode: 2 credits / tx
+	// Method: eth_getTransactionReceipt
+	// See: https://ethereum.github.io/execution-apis/api-documentation/
+	EthGetTransactionReceiptBatch ReceiptsFetchingMethod = 1 << iota
+	// AlchemyGetTransactionReceipts is a special receipt fetching method provided by Alchemy.
+	// Available in:
+	//   - Alchemy: 250 CU total
+	// Method: alchemy_getTransactionReceipts
+	// Params:
+	//   - object with "blockNumber" or "blockHash" field
+	// Returns: "array of receipts" - docs lie, array is wrapped in a struct with single "receipts" field
+	// See: https://docs.alchemy.com/reference/alchemy-gettransactionreceipts#alchemy_gettransactionreceipts
+	AlchemyGetTransactionReceipts
+	// DebugGetRawReceipts is a debug method from Geth, faster by avoiding serialization and metadata overhead.
+	// Ideal for fast syncing from a local geth node.
+	// Available in:
+	//   - Geth: free
+	//   - QuickNode: 22 credits maybe? Unknown price, undocumented ("debug_getblockreceipts" exists in table though?)
+	// Method: debug_getRawReceipts
+	// Params:
+	//   - string presenting a block number or hash
+	// Returns: list of strings, hex encoded RLP of receipts data. "consensus-encoding of all receipts in a single block"
+	// See: https://geth.ethereum.org/docs/rpc/ns-debug#debug_getrawreceipts
+	DebugGetRawReceipts
+	// ParityGetBlockReceipts is an old parity method, which has been adopted by Nethermind and some RPC providers.
+	// Available in:
+	//   - Alchemy: 500 CU total
+	//   - QuickNode: 59 credits - docs are wrong, not actually available anymore.
+	//   - Any open-ethereum/parity legacy: free
+	//   - Nethermind: free
+	// Method: parity_getBlockReceipts
+	// Params:
+	//   Parity: "quantity or tag"
+	//   Alchemy: string with block hash, number in hex, or block tag.
+	//   Nethermind: very flexible: tag, number, hex or object with "requireCanonical"/"blockHash" fields.
+	// Returns: array of receipts
+	// See:
+	//   - Parity: https://openethereum.github.io/JSONRPC-parity-module#parity_getblockreceipts
+	//   - QuickNode: undocumented.
+	//   - Alchemy: https://docs.alchemy.com/reference/eth-getblockreceipts
+	//   - Nethermind: https://docs.nethermind.io/nethermind/ethereum-client/json-rpc/parity#parity_getblockreceipts
+	ParityGetBlockReceipts
+	// EthGetBlockReceipts is a non-standard receipt fetching method in the eth namespace,
+	// supported by some RPC platforms and Erigon.
+	// Available in:
+	//   - Alchemy: 500 CU total  (and deprecated)
+	//   - Erigon: free
+	//   - QuickNode: 59 credits total       (does not seem to work with block hash arg, inaccurate docs)
+	// Method: eth_getBlockReceipts
+	// Params:
+	//   - QuickNode: string, "quantity or tag", docs say incl. block hash, but API does not actually accept it.
+	//   - Alchemy: string, block hash / num (hex) / block tag
+	// Returns: array of receipts
+	// See:
+	//   - QuickNode: https://www.quicknode.com/docs/ethereum/eth_getBlockReceipts
+	//   - Alchemy: https://docs.alchemy.com/reference/eth-getblockreceipts
+	EthGetBlockReceipts
+
+	// Other:
+	//  - 250 credits, not supported, strictly worse than other options. In quicknode price-table.
+	// qn_getBlockWithReceipts - in price table, ? undocumented, but in quicknode "Single Flight RPC" description
+	// qn_getReceipts          - in price table, ? undocumented, but in quicknode "Single Flight RPC" description
+	// debug_getBlockReceipts  - ? undocumented, shows up in quicknode price table, not available.
+)
+
+// AvailableReceiptsFetchingMethods selects receipt fetching methods based on the RPC provider kind.
+func AvailableReceiptsFetchingMethods(kind RPCProviderKind) ReceiptsFetchingMethod {
+	switch kind {
+	case RPCKindAlchemy:
+		return AlchemyGetTransactionReceipts | EthGetTransactionReceiptBatch
+	case RPCKindQuickNode:
+		return DebugGetRawReceipts | EthGetBlockReceipts | EthGetTransactionReceiptBatch
+	case RPCKindInfura:
+		// Infura is big, but sadly does not support more optimized receipts fetching methods (yet?)
+		return EthGetTransactionReceiptBatch
+	case RPCKindParity:
+		return ParityGetBlockReceipts | EthGetTransactionReceiptBatch
+	case RPCKindNethermind:
+		return ParityGetBlockReceipts | EthGetTransactionReceiptBatch
+	case RPCKindDebugGeth:
+		return DebugGetRawReceipts | EthGetTransactionReceiptBatch
+	case RPCKindErigon:
+		return EthGetBlockReceipts | EthGetTransactionReceiptBatch
+	case RPCKindBasic:
+		return EthGetTransactionReceiptBatch
+	case RPCKindAny:
+		// if it's any kind of RPC provider, then try all methods
+		return AlchemyGetTransactionReceipts | EthGetBlockReceipts |
+			DebugGetRawReceipts | ParityGetBlockReceipts | EthGetTransactionReceiptBatch
+	default:
+		return EthGetTransactionReceiptBatch
+	}
+}
+
+// PickBestReceiptsFetchingMethod selects an RPC method that is still available,
+// and optimal for fetching the given number of tx receipts from the specified provider kind.
+func PickBestReceiptsFetchingMethod(kind RPCProviderKind, available ReceiptsFetchingMethod, txCount uint64) ReceiptsFetchingMethod {
+	// If we have optimized methods available, it makes sense to use them, but only if the cost is
+	// lower than fetching transactions one by one with the standard receipts RPC method.
+	if kind == RPCKindAlchemy {
+		if available&AlchemyGetTransactionReceipts != 0 && txCount > 250/15 {
+			return AlchemyGetTransactionReceipts
+		}
+		if available&EthGetBlockReceipts != 0 && txCount > 500/15 {
+			return EthGetBlockReceipts
+		}
+		if available&ParityGetBlockReceipts != 0 && txCount > 500/15 {
+			return ParityGetBlockReceipts
+		}
+		return EthGetTransactionReceiptBatch
+	} else if kind == RPCKindQuickNode {
+		if available&DebugGetRawReceipts != 0 {
+			return DebugGetRawReceipts
+		}
+		if available&EthGetBlockReceipts != 0 && txCount > 59/2 {
+			return EthGetBlockReceipts
+		}
+		if available&ParityGetBlockReceipts != 0 && txCount > 59/2 {
+			return ParityGetBlockReceipts
+		}
+		return EthGetTransactionReceiptBatch
+	}
+	// otherwise just find the first available method
+	x := ReceiptsFetchingMethod(1)
+	for x != 0 {
+		if available&x != 0 {
+			return x
+		}
+		x <<= 1
+	}
+	// otherwise fall back on per-tx fetching
+	return EthGetTransactionReceiptBatch
+}
+
+type rpcClient interface {
+	CallContext(ctx context.Context, result any, method string, args ...any) error
+	BatchCallContext(ctx context.Context, b []rpc.BatchElem) error
+}
+
+// receiptsFetchingJob runs the receipt fetching for a specific block,
+// and can re-run and adapt based on the fetching method preferences and errors communicated with the requester.
+type receiptsFetchingJob struct {
+	m sync.Mutex
+
+	requester ReceiptsRequester
+
+	client       rpcClient
+	maxBatchSize int
+
+	block       eth.BlockID
+	receiptHash common.Hash
+	txHashes    []common.Hash
+
+	fetcher *IterativeBatchCall[common.Hash, *types.Receipt]
+
+	result types.Receipts
+}
+
+func NewReceiptsFetchingJob(requester ReceiptsRequester, client rpcClient, maxBatchSize int, block eth.BlockID,
+	receiptHash common.Hash, txHashes []common.Hash) *receiptsFetchingJob {
+	return &receiptsFetchingJob{
+		requester:    requester,
+		client:       client,
+		maxBatchSize: maxBatchSize,
+		block:        block,
+		receiptHash:  receiptHash,
+		txHashes:     txHashes,
+	}
+}
+
+// ReceiptsRequester helps determine which receipts fetching method can be used,
+// and is given feedback upon receipt fetching errors to adapt the choice of method.
+type ReceiptsRequester interface {
+	PickReceiptsMethod(txCount uint64) ReceiptsFetchingMethod
+	OnReceiptsMethodErr(m ReceiptsFetchingMethod, err error)
+}
+
+// runFetcher retrieves the result by continuing previous batched receipt fetching work,
+// and starting this work if necessary.
+func (job *receiptsFetchingJob) runFetcher(ctx context.Context) error {
+	if job.fetcher == nil {
+		// start new work
+		job.fetcher = NewIterativeBatchCall[common.Hash, *types.Receipt](
+			job.txHashes,
+			makeReceiptRequest,
+			job.client.BatchCallContext,
+			job.maxBatchSize,
+		)
+	}
+	// Fetch all receipts
+	for {
+		if err := job.fetcher.Fetch(ctx); err == io.EOF {
+			break
+		} else if err != nil {
+			return err
+		}
+	}
+	result, err := job.fetcher.Result()
+	if err != nil { // errors if results are not available yet, should never happen.
+		return err
+	}
+	if err := validateReceipts(job.block, job.receiptHash, job.txHashes, result); err != nil {
+		job.fetcher.Reset() // if results are fetched but invalid, try restart all the fetching to try and get valid data.
+		return err
+	}
+	// Remember the result, and don't keep the fetcher and tx hashes around for longer than needed
+	job.result = result
+	job.fetcher = nil
+	job.txHashes = nil
+	return nil
+}
+
+// receiptsWrapper is a decoding type util. Alchemy in particular wraps the receipts array result.
+type receiptsWrapper struct {
+	Receipts []*types.Receipt `json:"receipts"`
+}
+
+// runAltMethod retrieves the result by fetching all receipts at once,
+// using the given non-standard receipt fetching method.
+func (job *receiptsFetchingJob) runAltMethod(ctx context.Context, m ReceiptsFetchingMethod) error {
+	var result []*types.Receipt
+	var err error
+	switch m {
+	case AlchemyGetTransactionReceipts:
+		var tmp receiptsWrapper
+		err = job.client.CallContext(ctx, &tmp, "alchemy_getTransactionReceipts", blockHashParameter{BlockHash: job.block.Hash})
+		result = tmp.Receipts
+	case DebugGetRawReceipts:
+		var rawReceipts []hexutil.Bytes
+		err = job.client.CallContext(ctx, &rawReceipts, "debug_getRawReceipts", job.block.Hash)
+		if err == nil {
+			if len(rawReceipts) == len(job.txHashes) {
+				result = make([]*types.Receipt, len(rawReceipts))
+				totalIndex := uint(0)
+				for i, r := range rawReceipts {
+					var x types.Receipt
+					_ = x.UnmarshalBinary(r) // safe to ignore, we verify receipts against the receipts hash later
+					x.TxHash = job.txHashes[i]
+					x.BlockHash = job.block.Hash
+					x.BlockNumber = new(big.Int).SetUint64(job.block.Number)
+					x.TransactionIndex = uint(i)
+					for _, l := range x.Logs {
+						l.BlockNumber = job.block.Number
+						l.TxHash = x.TxHash
+						l.TxIndex = uint(i)
+						l.BlockHash = job.block.Hash
+						l.Index = totalIndex
+						totalIndex += 1
+					}
+					result[i] = &x
+				}
+			} else {
+				err = fmt.Errorf("got %d raw receipts, but expected %d", len(rawReceipts), len(job.txHashes))
+			}
+		}
+	case ParityGetBlockReceipts:
+		err = job.client.CallContext(ctx, &result, "parity_getBlockReceipts", job.block.Hash)
+	case EthGetBlockReceipts:
+		err = job.client.CallContext(ctx, &result, "eth_getBlockReceipts", job.block.Hash)
+	default:
+		err = fmt.Errorf("unknown receipt fetching method: %d", uint64(m))
+	}
+	if err != nil {
+		job.requester.OnReceiptsMethodErr(m, err)
+		return err
+	} else {
+		if err := validateReceipts(job.block, job.receiptHash, job.txHashes, result); err != nil {
+			return err
+		}
+		job.result = result
+		return nil
+	}
+}
+
+// Fetch makes the job fetch the receipts, and returns the results, if any.
+// An error may be returned if the fetching is not successfully completed,
+// and fetching may be continued/re-attempted by calling Fetch again.
+// The job caches the result, so repeated Fetches add no additional cost.
+// Fetch is safe to be called concurrently, and will lock to avoid duplicate work or internal inconsistency.
+func (job *receiptsFetchingJob) Fetch(ctx context.Context) (types.Receipts, error) {
+	job.m.Lock()
+	defer job.m.Unlock()
+
+	if job.result != nil {
+		return job.result, nil
+	}
+
+	m := job.requester.PickReceiptsMethod(uint64(len(job.txHashes)))
+
+	if m == EthGetTransactionReceiptBatch {
+		if err := job.runFetcher(ctx); err != nil {
+			return nil, err
+		}
+	} else {
+		if err := job.runAltMethod(ctx, m); err != nil {
+			return nil, err
+		}
+	}
+
+	return job.result, nil
 }

op-node/sources/types.go

@@ -4,19 +4,23 @@ import (
 	"context"
 	"fmt"
 	"math/big"
+	"strings"
 
 	"github.com/holiman/uint256"
 
-	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethereum/go-ethereum/trie"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
 )
 
 type BatchCallContextFn func(ctx context.Context, b []rpc.BatchElem) error
 
+type CallContextFn func(ctx context.Context, result any, method string, args ...any) error
+
 // Note: these types are used, instead of the geth types, to enable:
 // - batched calls of many block requests (standard bindings do extra uncle-header fetches, cannot be batched nicely)
 // - ignore uncle data (does not even exist anymore post-Merge)
@@ -258,3 +262,27 @@ func (block *rpcBlock) ExecutionPayload(trustCache bool) (*eth.ExecutionPayload,
 		Transactions:  opaqueTxs,
 	}, nil
 }
+
+// blockHashParameter is used as "block parameter":
+// Some Nethermind and Alchemy RPC endpoints require an object to identify a block, instead of a string.
+type blockHashParameter struct {
+	BlockHash common.Hash `json:"blockHash"`
+}
+
+// unusableMethod identifies if an error indicates that the RPC method cannot be used as expected:
+// if it's an unknown method, or if parameters were invalid.
+func unusableMethod(err error) bool {
+	if rpcErr, ok := err.(rpc.Error); ok {
+		code := rpcErr.ErrorCode()
+		// method not found, or invalid params
+		if code == -32601 || code == -32602 {
+			return true
+		}
+	} else {
+		errText := strings.ToLower(err.Error())
+		if strings.Contains(errText, "unknown method") || strings.Contains(errText, "invalid param") || strings.Contains(errText, "is not available") {
+			return true
+		}
+	}
+	return false
+}

op-node/version/version.go

 package version
 
 var (
-	Version = "v0.10.4"
+	Version = "v0.10.5"
 	Meta    = "dev"
 )

op-proposer/cmd/main.go

@@ -13,7 +13,7 @@ import (
 )
 
 var (
-	Version   = "v0.10.4"
+	Version   = "v0.10.5"
 	GitCommit = ""
 	GitDate   = ""
 )

op-proposer/go.mod

@@ -4,9 +4,9 @@ go 1.18
 
 require (
 	github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3
-	github.com/ethereum-optimism/optimism/op-bindings v0.10.4
-	github.com/ethereum-optimism/optimism/op-node v0.10.4
-	github.com/ethereum-optimism/optimism/op-service v0.10.4
+	github.com/ethereum-optimism/optimism/op-bindings v0.10.5
+	github.com/ethereum-optimism/optimism/op-node v0.10.5
+	github.com/ethereum-optimism/optimism/op-service v0.10.5
 	github.com/ethereum/go-ethereum v1.10.26
 	github.com/stretchr/testify v1.8.1
 	github.com/urfave/cli v1.22.9

op-proposer/go.sum

@@ -107,12 +107,12 @@ github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3 h1:RWHKLhCrQThMfch+QJ1Z
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3/go.mod h1:QziizLAiF0KqyLdNJYD7O5cpDlaFMNZzlxYNcWsJUxs=
 github.com/ethereum-optimism/op-geth v0.0.0-20221216190603-60b51d600468 h1:7KgjBYDji5AKi42eRYI+n8Gs+ZJVilSASL3WBu82c3M=
 github.com/ethereum-optimism/op-geth v0.0.0-20221216190603-60b51d600468/go.mod h1:p0Yox74PhYlq1HvijrCBCD9A3cI7rXco7hT6KrQr+rY=
-github.com/ethereum-optimism/optimism/op-bindings v0.10.4 h1:CFn4+t0FUrBG5DmkKyYrLbGmzHWLdLv8QdUnlklvozc=
-github.com/ethereum-optimism/optimism/op-bindings v0.10.4/go.mod h1:philKV8erP02ggjk2mRIdvJd2ZjMzpmqu0+zwwzKmNw=
-github.com/ethereum-optimism/optimism/op-node v0.10.4 h1:ZXqfrFKgb6W4ZLbkfO9NlgaQ1djBCCPzNGbd6TgehVI=
-github.com/ethereum-optimism/optimism/op-node v0.10.4/go.mod h1:avOLjMLxzB5QB7HmiLlpNkyS93QVHdr0AttRdfYGX3Y=
-github.com/ethereum-optimism/optimism/op-service v0.10.4 h1:WKqNyOBkdJ0ZdlGiDPROZMaWfYxpsYjA5Anb0Bkl5m4=
-github.com/ethereum-optimism/optimism/op-service v0.10.4/go.mod h1:7INvNCJGwVgNT4gz9Yupx7PAEJeu+F/JtHKv1fOr+9Q=
+github.com/ethereum-optimism/optimism/op-bindings v0.10.5 h1:CcVHlC1QW3z6X/GYhwRfx7gz3WWho6hnVObzuNDLUS4=
+github.com/ethereum-optimism/optimism/op-bindings v0.10.5/go.mod h1:9ZSUq/rjlzp3uYyBN4sZmhTc3oZgDVqJ4wrUja7vj6c=
+github.com/ethereum-optimism/optimism/op-node v0.10.5 h1:Fp9xzbcfqGQEicpbrcWKED2uqZOSZscID7aN56KDTok=
+github.com/ethereum-optimism/optimism/op-node v0.10.5/go.mod h1:GPsNceaHhDJZcxH7CsdJYuqAqUuE9xz69MzO7Qu6doo=
+github.com/ethereum-optimism/optimism/op-service v0.10.5 h1:N0hG156WHOP0C60rkN0JI8hWkmKW5LvR4pppSgJiU4M=
+github.com/ethereum-optimism/optimism/op-service v0.10.5/go.mod h1:wbtHqi1fv00B3agj7a2zdP3OFanEfGZ23zPgGgFCF/c=
 github.com/fjl/memsize v0.0.1 h1:+zhkb+dhUgx0/e+M8sF0QqiouvMQUiKR+QYvdxIOKcQ=
 github.com/fjl/memsize v0.0.1/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=

packages/contracts-bedrock/deploy/020-SystemDictatorSteps-1.ts

+import assert from 'assert'
+
+import { ethers } from 'ethers'
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import { awaitCondition } from '@eth-optimism/core-utils'
+import '@eth-optimism/hardhat-deploy-config'
+import 'hardhat-deploy'
+import '@nomiclabs/hardhat-ethers'
+
+import {
+  assertContractVariable,
+  getContractsFromArtifacts,
+  getDeploymentAddress,
+  doStep,
+  jsonifyTransaction,
+} from '../src/deploy-utils'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deployer } = await hre.getNamedAccounts()
+
+  // Set up required contract references.
+  const [
+    SystemDictator,
+    ProxyAdmin,
+    AddressManager,
+    L1CrossDomainMessenger,
+    L1StandardBridgeProxy,
+    L1StandardBridgeProxyWithSigner,
+    L1ERC721BridgeProxy,
+    L1ERC721BridgeProxyWithSigner,
+  ] = await getContractsFromArtifacts(hre, [
+    {
+      name: 'SystemDictatorProxy',
+      iface: 'SystemDictator',
+      signerOrProvider: deployer,
+    },
+    {
+      name: 'ProxyAdmin',
+      signerOrProvider: deployer,
+    },
+    {
+      name: 'Lib_AddressManager',
+      signerOrProvider: deployer,
+    },
+    {
+      name: 'Proxy__OVM_L1CrossDomainMessenger',
+      iface: 'L1CrossDomainMessenger',
+      signerOrProvider: deployer,
+    },
+    {
+      name: 'Proxy__OVM_L1StandardBridge',
+    },
+    {
+      name: 'Proxy__OVM_L1StandardBridge',
+      signerOrProvider: deployer,
+    },
+    {
+      name: 'L1ERC721BridgeProxy',
+    },
+    {
+      name: 'L1ERC721BridgeProxy',
+      signerOrProvider: deployer,
+    },
+  ])
+
+  // If we have the key for the controller then we don't need to wait for external txns.
+  const isLiveDeployer =
+    deployer.toLowerCase() === hre.deployConfig.controller.toLowerCase()
+
+  // Transfer ownership of the ProxyAdmin to the SystemDictator.
+  if ((await ProxyAdmin.owner()) !== SystemDictator.address) {
+    console.log(`Setting ProxyAdmin owner to MSD`)
+    await ProxyAdmin.transferOwnership(SystemDictator.address)
+  } else {
+    console.log(`Proxy admin already owned by MSD`)
+  }
+
+  // We don't need to transfer proxy addresses if we're already beyond the proxy transfer step.
+  const needsProxyTransfer =
+    (await SystemDictator.currentStep()) <=
+    (await SystemDictator.PROXY_TRANSFER_STEP())
+
+  // Transfer ownership of the AddressManager to SystemDictator.
+  if (
+    needsProxyTransfer &&
+    (await AddressManager.owner()) !== SystemDictator.address
+  ) {
+    if (isLiveDeployer) {
+      console.log(`Setting AddressManager owner to MSD`)
+      await AddressManager.transferOwnership(SystemDictator.address)
+    } else {
+      const tx = await AddressManager.populateTransaction.transferOwnership(
+        SystemDictator.address
+      )
+      console.log(`Please transfer AddressManager owner to MSD`)
+      console.log(`AddressManager address: ${AddressManager.address}`)
+      console.log(`MSD address: ${SystemDictator.address}`)
+      console.log(`JSON:`)
+      console.log(jsonifyTransaction(tx))
+    }
+
+    // Wait for the ownership transfer to complete.
+    await awaitCondition(
+      async () => {
+        const owner = await AddressManager.owner()
+        return owner === SystemDictator.address
+      },
+      30000,
+      1000
+    )
+  } else {
+    console.log(`AddressManager already owned by the SystemDictator`)
+  }
+
+  // Transfer ownership of the L1CrossDomainMessenger to SystemDictator.
+  if (
+    needsProxyTransfer &&
+    (await AddressManager.getAddress('OVM_L1CrossDomainMessenger')) !==
+      ethers.constants.AddressZero &&
+    (await L1CrossDomainMessenger.owner()) !== SystemDictator.address
+  ) {
+    if (isLiveDeployer) {
+      console.log(`Setting L1CrossDomainMessenger owner to MSD`)
+      await L1CrossDomainMessenger.transferOwnership(SystemDictator.address)
+    } else {
+      const tx =
+        await L1CrossDomainMessenger.populateTransaction.transferOwnership(
+          SystemDictator.address
+        )
+      console.log(`Please transfer L1CrossDomainMessenger owner to MSD`)
+      console.log(`L1XDM address: ${L1CrossDomainMessenger.address}`)
+      console.log(`MSD address: ${SystemDictator.address}`)
+      console.log(`JSON:`)
+      console.log(jsonifyTransaction(tx))
+    }
+
+    // Wait for the ownership transfer to complete.
+    await awaitCondition(
+      async () => {
+        const owner = await L1CrossDomainMessenger.owner()
+        return owner === SystemDictator.address
+      },
+      30000,
+      1000
+    )
+  } else {
+    console.log(`L1CrossDomainMessenger already owned by MSD`)
+  }
+
+  // Transfer ownership of the L1StandardBridge (proxy) to SystemDictator.
+  if (
+    needsProxyTransfer &&
+    (await L1StandardBridgeProxy.callStatic.getOwner({
+      from: ethers.constants.AddressZero,
+    })) !== SystemDictator.address
+  ) {
+    if (isLiveDeployer) {
+      console.log(`Setting L1StandardBridge owner to MSD`)
+      await L1StandardBridgeProxyWithSigner.setOwner(SystemDictator.address)
+    } else {
+      const tx = await L1StandardBridgeProxy.populateTransaction.setOwner(
+        SystemDictator.address
+      )
+      console.log(`Please transfer L1StandardBridge (proxy) owner to MSD`)
+      console.log(
+        `L1StandardBridgeProxy address: ${L1StandardBridgeProxy.address}`
+      )
+      console.log(`MSD address: ${SystemDictator.address}`)
+      console.log(`JSON:`)
+      console.log(jsonifyTransaction(tx))
+    }
+
+    // Wait for the ownership transfer to complete.
+    await awaitCondition(
+      async () => {
+        const owner = await L1StandardBridgeProxy.callStatic.getOwner({
+          from: ethers.constants.AddressZero,
+        })
+        return owner === SystemDictator.address
+      },
+      30000,
+      1000
+    )
+  } else {
+    console.log(`L1StandardBridge already owned by MSD`)
+  }
+
+  // Transfer ownership of the L1ERC721Bridge (proxy) to SystemDictator.
+  if (
+    needsProxyTransfer &&
+    (await L1ERC721BridgeProxy.callStatic.admin({
+      from: ethers.constants.AddressZero,
+    })) !== SystemDictator.address
+  ) {
+    if (isLiveDeployer) {
+      console.log(`Setting L1ERC721Bridge owner to MSD`)
+      await L1ERC721BridgeProxyWithSigner.changeAdmin(SystemDictator.address)
+    } else {
+      const tx = await L1ERC721BridgeProxy.populateTransaction.changeAdmin(
+        SystemDictator.address
+      )
+      console.log(`Please transfer L1ERC721Bridge (proxy) owner to MSD`)
+      console.log(`L1ERC721BridgeProxy address: ${L1ERC721BridgeProxy.address}`)
+      console.log(`MSD address: ${SystemDictator.address}`)
+      console.log(`JSON:`)
+      console.log(jsonifyTransaction(tx))
+    }
+
+    // Wait for the ownership transfer to complete.
+    await awaitCondition(
+      async () => {
+        const owner = await L1ERC721BridgeProxy.callStatic.admin({
+          from: ethers.constants.AddressZero,
+        })
+        return owner === SystemDictator.address
+      },
+      30000,
+      1000
+    )
+  } else {
+    console.log(`L1ERC721Bridge already owned by MSD`)
+  }
+
+  // Step 1 is a freebie, it doesn't impact the system.
+  await doStep({
+    isLiveDeployer,
+    SystemDictator,
+    step: 1,
+    message: `
+      Step 1 will configure the ProxyAdmin contract, you can safely execute this step at any time
+      without impacting the functionality of the rest of the system.
+    `,
+    checks: async () => {
+      await assertContractVariable(
+        ProxyAdmin,
+        'addressManager',
+        AddressManager.address
+      )
+      assert(
+        (await ProxyAdmin.implementationName(
+          getDeploymentAddress(hre, 'Proxy__OVM_L1CrossDomainMessenger')
+        )) === 'OVM_L1CrossDomainMessenger'
+      )
+      assert(
+        (await ProxyAdmin.proxyType(
+          getDeploymentAddress(hre, 'Proxy__OVM_L1CrossDomainMessenger')
+        )) === 2
+      )
+      assert(
+        (await ProxyAdmin.proxyType(
+          getDeploymentAddress(hre, 'Proxy__OVM_L1StandardBridge')
+        )) === 1
+      )
+    },
+  })
+
+  // Step 2 shuts down the system.
+  await doStep({
+    isLiveDeployer,
+    SystemDictator,
+    step: 2,
+    message: `
+      Step 2 will stop deposits and withdrawals via the L1CrossDomainMessenger and will stop the
+      DTL from syncing new deposits via the CTC, effectively shutting down the legacy system. Once
+      this step has been executed, you should immediately begin the L2 migration process. If you
+      need to restart the system, run exit1() followed by finalize().
+    `,
+    checks: async () => {
+      assert(
+        (await AddressManager.getAddress('OVM_L1CrossDomainMessenger')) ===
+          ethers.constants.AddressZero
+      )
+    },
+  })
+}
+
+deployFn.tags = ['SystemDictatorSteps', 'phase1']
+
+export default deployFn

packages/contracts-bedrock/deploy/020-SystemDictatorSteps.ts → packages/contracts-bedrock/deploy/021-SystemDictatorSteps-2.ts

@@ -10,8 +10,9 @@ import '@nomiclabs/hardhat-ethers'
 import {
   assertContractVariable,
   getContractsFromArtifacts,
-  getDeploymentAddress,
   jsonifyTransaction,
+  isStep,
+  doStep,
 } from '../src/deploy-utils'
 
 const deployFn: DeployFunction = async (hre) => {
@@ -24,13 +25,10 @@ const deployFn: DeployFunction = async (hre) => {
     AddressManager,
     L1CrossDomainMessenger,
     L1StandardBridgeProxy,
-    L1StandardBridgeProxyWithSigner,
     L1StandardBridge,
     L2OutputOracle,
     OptimismPortal,
     OptimismMintableERC20Factory,
-    L1ERC721BridgeProxy,
-    L1ERC721BridgeProxyWithSigner,
     L1ERC721Bridge,
     SystemConfigProxy,
   ] = await getContractsFromArtifacts(hre, [
@@ -55,10 +53,6 @@ const deployFn: DeployFunction = async (hre) => {
     {
       name: 'Proxy__OVM_L1StandardBridge',
     },
-    {
-      name: 'Proxy__OVM_L1StandardBridge',
-      signerOrProvider: deployer,
-    },
     {
       name: 'Proxy__OVM_L1StandardBridge',
       iface: 'L1StandardBridge',
@@ -79,13 +73,6 @@ const deployFn: DeployFunction = async (hre) => {
       iface: 'OptimismMintableERC20Factory',
       signerOrProvider: deployer,
     },
-    {
-      name: 'L1ERC721BridgeProxy',
-    },
-    {
-      name: 'L1ERC721BridgeProxy',
-      signerOrProvider: deployer,
-    },
     {
       name: 'L1ERC721BridgeProxy',
       iface: 'L1ERC721Bridge',
@@ -102,266 +89,10 @@ const deployFn: DeployFunction = async (hre) => {
   const isLiveDeployer =
     deployer.toLowerCase() === hre.deployConfig.controller.toLowerCase()
 
-  // Transfer ownership of the ProxyAdmin to the SystemDictator.
-  if ((await ProxyAdmin.owner()) !== SystemDictator.address) {
-    console.log(`Setting ProxyAdmin owner to MSD`)
-    await ProxyAdmin.transferOwnership(SystemDictator.address)
-  } else {
-    console.log(`Proxy admin already owned by MSD`)
-  }
-
-  // We don't need to transfer proxy addresses if we're already beyond the proxy transfer step.
-  const needsProxyTransfer =
-    (await SystemDictator.currentStep()) <=
-    (await SystemDictator.PROXY_TRANSFER_STEP())
-
-  // Transfer ownership of the AddressManager to SystemDictator.
-  if (
-    needsProxyTransfer &&
-    (await AddressManager.owner()) !== SystemDictator.address
-  ) {
-    if (isLiveDeployer) {
-      console.log(`Setting AddressManager owner to MSD`)
-      await AddressManager.transferOwnership(SystemDictator.address)
-    } else {
-      const tx = await AddressManager.populateTransaction.transferOwnership(
-        SystemDictator.address
-      )
-      console.log(`Please transfer AddressManager owner to MSD`)
-      console.log(`AddressManager address: ${AddressManager.address}`)
-      console.log(`MSD address: ${SystemDictator.address}`)
-      console.log(`JSON:`)
-      console.log(jsonifyTransaction(tx))
-    }
-
-    // Wait for the ownership transfer to complete.
-    await awaitCondition(
-      async () => {
-        const owner = await AddressManager.owner()
-        return owner === SystemDictator.address
-      },
-      30000,
-      1000
-    )
-  } else {
-    console.log(`AddressManager already owned by the SystemDictator`)
-  }
-
-  // Transfer ownership of the L1CrossDomainMessenger to SystemDictator.
-  if (
-    needsProxyTransfer &&
-    (await AddressManager.getAddress('OVM_L1CrossDomainMessenger')) !==
-      ethers.constants.AddressZero &&
-    (await L1CrossDomainMessenger.owner()) !== SystemDictator.address
-  ) {
-    if (isLiveDeployer) {
-      console.log(`Setting L1CrossDomainMessenger owner to MSD`)
-      await L1CrossDomainMessenger.transferOwnership(SystemDictator.address)
-    } else {
-      const tx =
-        await L1CrossDomainMessenger.populateTransaction.transferOwnership(
-          SystemDictator.address
-        )
-      console.log(`Please transfer L1CrossDomainMessenger owner to MSD`)
-      console.log(`L1XDM address: ${L1CrossDomainMessenger.address}`)
-      console.log(`MSD address: ${SystemDictator.address}`)
-      console.log(`JSON:`)
-      console.log(jsonifyTransaction(tx))
-    }
-
-    // Wait for the ownership transfer to complete.
-    await awaitCondition(
-      async () => {
-        const owner = await L1CrossDomainMessenger.owner()
-        return owner === SystemDictator.address
-      },
-      30000,
-      1000
-    )
-  } else {
-    console.log(`L1CrossDomainMessenger already owned by MSD`)
-  }
-
-  // Transfer ownership of the L1StandardBridge (proxy) to SystemDictator.
-  if (
-    needsProxyTransfer &&
-    (await L1StandardBridgeProxy.callStatic.getOwner({
-      from: ethers.constants.AddressZero,
-    })) !== SystemDictator.address
-  ) {
-    if (isLiveDeployer) {
-      console.log(`Setting L1StandardBridge owner to MSD`)
-      await L1StandardBridgeProxyWithSigner.setOwner(SystemDictator.address)
-    } else {
-      const tx = await L1StandardBridgeProxy.populateTransaction.setOwner(
-        SystemDictator.address
-      )
-      console.log(`Please transfer L1StandardBridge (proxy) owner to MSD`)
-      console.log(
-        `L1StandardBridgeProxy address: ${L1StandardBridgeProxy.address}`
-      )
-      console.log(`MSD address: ${SystemDictator.address}`)
-      console.log(`JSON:`)
-      console.log(jsonifyTransaction(tx))
-    }
-
-    // Wait for the ownership transfer to complete.
-    await awaitCondition(
-      async () => {
-        const owner = await L1StandardBridgeProxy.callStatic.getOwner({
-          from: ethers.constants.AddressZero,
-        })
-        return owner === SystemDictator.address
-      },
-      30000,
-      1000
-    )
-  } else {
-    console.log(`L1StandardBridge already owned by MSD`)
-  }
-
-  // Transfer ownership of the L1ERC721Bridge (proxy) to SystemDictator.
-  if (
-    needsProxyTransfer &&
-    (await L1ERC721BridgeProxy.callStatic.admin({
-      from: ethers.constants.AddressZero,
-    })) !== SystemDictator.address
-  ) {
-    if (isLiveDeployer) {
-      console.log(`Setting L1ERC721Bridge owner to MSD`)
-      await L1ERC721BridgeProxyWithSigner.changeAdmin(SystemDictator.address)
-    } else {
-      const tx = await L1ERC721BridgeProxy.populateTransaction.changeAdmin(
-        SystemDictator.address
-      )
-      console.log(`Please transfer L1ERC721Bridge (proxy) owner to MSD`)
-      console.log(`L1ERC721BridgeProxy address: ${L1ERC721BridgeProxy.address}`)
-      console.log(`MSD address: ${SystemDictator.address}`)
-      console.log(`JSON:`)
-      console.log(jsonifyTransaction(tx))
-    }
-
-    // Wait for the ownership transfer to complete.
-    await awaitCondition(
-      async () => {
-        const owner = await L1ERC721BridgeProxy.callStatic.admin({
-          from: ethers.constants.AddressZero,
-        })
-        return owner === SystemDictator.address
-      },
-      30000,
-      1000
-    )
-  } else {
-    console.log(`L1ERC721Bridge already owned by MSD`)
-  }
-
-  /**
-   * Mini helper for checking if the current step is a target step.
-   *
-   * @param step Target step.
-   * @returns True if the current step is the target step.
-   */
-  const isStep = async (step: number): Promise<boolean> => {
-    return (await SystemDictator.currentStep()) === step
-  }
-
-  /**
-   * Mini helper for executing a given step.
-   *
-   * @param opts Options for executing the step.
-   * @param opts.step Step to execute.
-   * @param opts.message Message to print before executing the step.
-   * @param opts.checks Checks to perform after executing the step.
-   */
-  const doStep = async (opts: {
-    step: number
-    message: string
-    checks: () => Promise<void>
-  }): Promise<void> => {
-    if (!(await isStep(opts.step))) {
-      console.log(`Step already completed: ${opts.step}`)
-      return
-    }
-
-    // Extra message to help the user understand what's going on.
-    console.log(opts.message)
-
-    // Either automatically or manually execute the step.
-    if (isLiveDeployer) {
-      console.log(`Executing step ${opts.step}...`)
-      await SystemDictator[`step${opts.step}`]()
-    } else {
-      const tx = await SystemDictator.populateTransaction[`step${opts.step}`]()
-      console.log(`Please execute step ${opts.step}...`)
-      console.log(`MSD address: ${SystemDictator.address}`)
-      console.log(`JSON:`)
-      console.log(jsonifyTransaction(tx))
-    }
-
-    // Wait for the step to complete.
-    await awaitCondition(
-      async () => {
-        return (await SystemDictator.currentStep()) === opts.step + 1
-      },
-      30000,
-      1000
-    )
-
-    // Perform post-step checks.
-    await opts.checks()
-  }
-
-  // Step 1 is a freebie, it doesn't impact the system.
-  await doStep({
-    step: 1,
-    message: `
-      Step 1 will configure the ProxyAdmin contract, you can safely execute this step at any time
-      without impacting the functionality of the rest of the system.
-    `,
-    checks: async () => {
-      await assertContractVariable(
-        ProxyAdmin,
-        'addressManager',
-        AddressManager.address
-      )
-      assert(
-        (await ProxyAdmin.implementationName(
-          getDeploymentAddress(hre, 'Proxy__OVM_L1CrossDomainMessenger')
-        )) === 'OVM_L1CrossDomainMessenger'
-      )
-      assert(
-        (await ProxyAdmin.proxyType(
-          getDeploymentAddress(hre, 'Proxy__OVM_L1CrossDomainMessenger')
-        )) === 2
-      )
-      assert(
-        (await ProxyAdmin.proxyType(
-          getDeploymentAddress(hre, 'Proxy__OVM_L1StandardBridge')
-        )) === 1
-      )
-    },
-  })
-
-  // Step 2 shuts down the system.
-  await doStep({
-    step: 2,
-    message: `
-      Step 2 will stop deposits and withdrawals via the L1CrossDomainMessenger and will stop the
-      DTL from syncing new deposits via the CTC, effectively shutting down the legacy system. Once
-      this step has been executed, you should immediately begin the L2 migration process. If you
-      need to restart the system, run exit1() followed by finalize().
-    `,
-    checks: async () => {
-      assert(
-        (await AddressManager.getAddress('OVM_L1CrossDomainMessenger')) ===
-          ethers.constants.AddressZero
-      )
-    },
-  })
-
   // Step 3 clears out some state from the AddressManager.
   await doStep({
+    isLiveDeployer,
+    SystemDictator,
     step: 3,
     message: `
       Step 3 will clear out some legacy state from the AddressManager. Once you execute this step,
@@ -399,6 +130,8 @@ const deployFn: DeployFunction = async (hre) => {
 
   // Step 4 transfers ownership of the AddressManager and L1StandardBridge to the ProxyAdmin.
   await doStep({
+    isLiveDeployer,
+    SystemDictator,
     step: 4,
     message: `
       Step 4 will transfer ownership of the AddressManager and L1StandardBridge to the ProxyAdmin.
@@ -415,7 +148,10 @@ const deployFn: DeployFunction = async (hre) => {
   })
 
   // Make sure the dynamic system configuration has been set.
-  if ((await isStep(5)) && !(await SystemDictator.dynamicConfigSet())) {
+  if (
+    (await isStep(SystemDictator, 5)) &&
+    !(await SystemDictator.dynamicConfigSet())
+  ) {
     console.log(`
       You must now set the dynamic L2OutputOracle configuration by calling the function
       updateL2OutputOracleDynamicConfig. You will need to provide the
@@ -461,6 +197,8 @@ const deployFn: DeployFunction = async (hre) => {
 
   // Step 5 initializes all contracts and pauses the new L1CrossDomainMessenger.
   await doStep({
+    isLiveDeployer,
+    SystemDictator,
     step: 5,
     message: `
       Step 5 will initialize all Bedrock contracts but will leave the new L1CrossDomainMessenger
@@ -575,6 +313,8 @@ const deployFn: DeployFunction = async (hre) => {
 
   // Step 6 unpauses the new L1CrossDomainMessenger.
   await doStep({
+    isLiveDeployer,
+    SystemDictator,
     step: 6,
     message: `
       Step 6 will unpause the new L1CrossDomainMessenger. After this step is executed, users will
@@ -587,7 +327,7 @@ const deployFn: DeployFunction = async (hre) => {
   })
 
   // At the end we finalize the upgrade.
-  if (await isStep(7)) {
+  if (await isStep(SystemDictator, 7)) {
     console.log(`
       You must now finalize the upgrade by calling finalize() on the SystemDictator. This will
       transfer ownership of the ProxyAdmin and the L1CrossDomainMessenger to the final system owner
@@ -626,6 +366,6 @@ const deployFn: DeployFunction = async (hre) => {
   }
 }
 
-deployFn.tags = ['SystemDictatorSteps']
+deployFn.tags = ['SystemDictatorSteps', 'phase2']
 
 export default deployFn

packages/contracts-bedrock/src/deploy-utils.ts

@@ -3,7 +3,7 @@ import assert from 'assert'
 import { ethers, Contract } from 'ethers'
 import { Provider } from '@ethersproject/abstract-provider'
 import { Signer } from '@ethersproject/abstract-signer'
-import { sleep } from '@eth-optimism/core-utils'
+import { awaitCondition, sleep } from '@eth-optimism/core-utils'
 import { HardhatRuntimeEnvironment } from 'hardhat/types'
 import { Deployment, DeployResult } from 'hardhat-deploy/dist/types'
 import 'hardhat-deploy'
@@ -277,6 +277,12 @@ export const getDeploymentAddress = async (
   return deployment.address
 }
 
+/**
+ * JSON-ifies an ethers transaction object.
+ *
+ * @param tx Ethers transaction object.
+ * @returns JSON-ified transaction object.
+ */
 export const jsonifyTransaction = (tx: ethers.PopulatedTransaction): string => {
   return JSON.stringify(
     {
@@ -289,3 +295,63 @@ export const jsonifyTransaction = (tx: ethers.PopulatedTransaction): string => {
     2
   )
 }
+
+/**
+ * Mini helper for checking if the current step is a target step.
+ *
+ * @param dictator SystemDictator contract.
+ * @param step Target step.
+ * @returns True if the current step is the target step.
+ */
+export const isStep = async (
+  dictator: ethers.Contract,
+  step: number
+): Promise<boolean> => {
+  return (await dictator.currentStep()) === step
+}
+
+/**
+ * Mini helper for executing a given step.
+ *
+ * @param opts Options for executing the step.
+ * @param opts.isLiveDeployer True if the deployer is live.
+ * @param opts.SystemDictator SystemDictator contract.
+ * @param opts.step Step to execute.
+ * @param opts.message Message to print before executing the step.
+ * @param opts.checks Checks to perform after executing the step.
+ */
+export const doStep = async (opts: {
+  isLiveDeployer?: boolean
+  SystemDictator: ethers.Contract
+  step: number
+  message: string
+  checks: () => Promise<void>
+}): Promise<void> => {
+  if (!(await isStep(opts.SystemDictator, opts.step))) {
+    console.log(`Step already completed: ${opts.step}`)
+    return
+  }
+
+  // Extra message to help the user understand what's going on.
+  console.log(opts.message)
+
+  // Either automatically or manually execute the step.
+  if (opts.isLiveDeployer) {
+    console.log(`Executing step ${opts.step}...`)
+    await opts.SystemDictator[`step${opts.step}`]()
+  } else {
+    console.log(`Please execute step ${opts.step}...`)
+  }
+
+  // Wait for the step to complete.
+  await awaitCondition(
+    async () => {
+      return isStep(opts.SystemDictator, opts.step + 1)
+    },
+    30000,
+    1000
+  )
+
+  // Perform post-step checks.
+  await opts.checks()
+}

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

@@ -41,7 +41,11 @@ const checkPredeploys = async (hre: HardhatRuntimeEnvironment) => {
       throw new Error(`no code found at ${addr}`)
     }
 
-    if (addr === predeploys.GovernanceToken || addr === predeploys.ProxyAdmin) {
+    if (
+      addr === predeploys.GovernanceToken ||
+      addr === predeploys.ProxyAdmin ||
+      addr === predeploys.WETH9
+    ) {
       continue
     }
 
@@ -370,7 +374,6 @@ const check = {
   // - check name
   // - check symbol
   // - check decimals
-  // - is behind a proxy
   WETH9: async (hre: HardhatRuntimeEnvironment) => {
     const WETH9 = await hre.ethers.getContractAt('WETH9', predeploys.WETH9)
 
@@ -385,9 +388,6 @@ const check = {
     const decimals = await WETH9.decimals()
     assert(decimals === 18)
     console.log(`  - decimals: ${decimals}`)
-
-    await checkProxy(hre, 'WETH9')
-    await assertProxy(hre, 'WETH9')
   },
   // GovernanceToken
   // - not behind a proxy

packages/contracts-periphery/config/deploy/goerli.ts

+import { DeployConfig } from '../../src'
+
+const config: DeployConfig = {
+  ddd: '0x9C6373dE60c2D3297b18A8f964618ac46E011B58',
+  l2ProxyOwnerAddress: '0x60c5C9c98bcBd0b0F2fD89B24c16e533BaA8CdA3',
+  optimistName: 'Optimist',
+  optimistSymbol: 'OPTIMIST',
+  attestorAddress: '0x60c5C9c98bcBd0b0F2fD89B24c16e533BaA8CdA3',
+}
+
+export default config

packages/contracts-periphery/config/drippie/goerli.ts

+import { ethers } from 'ethers'
+
+import { DrippieConfig, Time } from '../../src'
+
+const config: DrippieConfig = {
+  BatcherBalance: {
+    interval: 1 * Time.DAY,
+    dripcheck: 'CheckBalanceLow',
+    checkparams: {
+      target: '0x7431310e026b69bfc676c0013e12a1a11411eec9',
+      threshold: ethers.utils.parseEther('50'),
+    },
+    actions: [
+      {
+        target: '0x7431310e026b69bfc676c0013e12a1a11411eec9',
+        value: ethers.utils.parseEther('100'),
+      },
+    ],
+  },
+  ProposerBalance: {
+    interval: 1 * Time.DAY,
+    dripcheck: 'CheckBalanceLow',
+    checkparams: {
+      target: '0x02b1786a85ec3f71fbbba46507780db7cf9014f6',
+      threshold: ethers.utils.parseEther('50'),
+    },
+    actions: [
+      {
+        target: '0x02b1786a85ec3f71fbbba46507780db7cf9014f6',
+        value: ethers.utils.parseEther('100'),
+      },
+    ],
+  },
+  GelatoBalance: {
+    interval: 1 * Time.DAY,
+    dripcheck: 'CheckGelatoLow',
+    checkparams: {
+      treasury: '0xf381dfd7a139caab83c26140e5595c0b85ddadcd',
+      recipient: '0xc37f6a6c4AB335E20d10F034B90386E2fb70bbF5',
+      threshold: ethers.utils.parseEther('0.1'),
+    },
+    actions: [
+      {
+        target: '0xf381dfd7a139caab83c26140e5595c0b85ddadcd',
+        value: ethers.utils.parseEther('1'),
+        data: {
+          fn: 'depositFunds',
+          args: [
+            // receiver
+            '0xc37f6a6c4AB335E20d10F034B90386E2fb70bbF5',
+            // token
+            '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+            // amount
+            ethers.utils.parseEther('1'),
+          ],
+        },
+      },
+    ],
+  },
+}
+
+export default config

packages/contracts-periphery/deployments/goerli/CheckBalanceHigh.json

+{
+  "address": "0x7eC64a8a591bFf829ff6C8be76074D540ACb813F",
+  "abi": [
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "address",
+              "name": "target",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "threshold",
+              "type": "uint256"
+            }
+          ],
+          "indexed": false,
+          "internalType": "struct CheckBalanceHigh.Params",
+          "name": "params",
+          "type": "tuple"
+        }
+      ],
+      "name": "_EventToExposeStructInABI__Params",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes",
+          "name": "_params",
+          "type": "bytes"
+        }
+      ],
+      "name": "check",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "transactionHash": "0x1d1543b42c1a5404d3b1794a399239d1e3f40c10e865d0f2e4a362a349d30a6e",
+  "receipt": {
+    "to": "0x4e59b44847b379578588920cA78FbF26c0B4956C",
+    "from": "0x9C6373dE60c2D3297b18A8f964618ac46E011B58",
+    "contractAddress": null,
+    "transactionIndex": 76,
+    "gasUsed": "176628",
+    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "blockHash": "0x0b10b7612a1de5326e045069eb60151e2fa615ce7d342b13acb14ba165edddb1",
+    "transactionHash": "0x1d1543b42c1a5404d3b1794a399239d1e3f40c10e865d0f2e4a362a349d30a6e",
+    "logs": [],
+    "blockNumber": 8182666,
+    "cumulativeGasUsed": "10050194",
+    "status": 1,
+    "byzantium": true
+  },
+  "args": [],
+  "numDeployments": 1,
+  "solcInputHash": "2373b7ba869baea4fec58e6e7f7b8988",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.16+commit.07a7930e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"threshold\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"struct CheckBalanceHigh.Params\",\"name\":\"params\",\"type\":\"tuple\"}],\"name\":\"_EventToExposeStructInABI__Params\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_params\",\"type\":\"bytes\"}],\"name\":\"check\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"_EventToExposeStructInABI__Params((address,uint256))\":{\"params\":{\"params\":\"Parameters to encode.\"}}},\"kind\":\"dev\",\"methods\":{\"check(bytes)\":{\"params\":{\"_params\":\"Encoded parameters for the drip check.\"},\"returns\":{\"_0\":\"Whether the drip should be executed.\"}}},\"title\":\"CheckBalanceHigh\",\"version\":1},\"userdoc\":{\"events\":{\"_EventToExposeStructInABI__Params((address,uint256))\":{\"notice\":\"External event used to help client-side tooling encode parameters.\"}},\"kind\":\"user\",\"methods\":{\"check(bytes)\":{\"notice\":\"Checks whether a drip should be executable.\"}},\"notice\":\"DripCheck for checking if an account's balance is above a given threshold.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/universal/drippie/dripchecks/CheckBalanceHigh.sol\":\"CheckBalanceHigh\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"contracts/universal/drippie/IDripCheck.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IDripCheck {\\n    // DripCheck contracts that want to take parameters as inputs MUST expose a struct called\\n    // Params and an event _EventForExposingParamsStructInABI(Params params). This makes it\\n    // possible to easily encode parameters on the client side. Solidity does not support generics\\n    // so it's not possible to do this with explicit typing.\\n\\n    /**\\n     * @notice Checks whether a drip should be executable.\\n     *\\n     * @param _params Encoded parameters for the drip check.\\n     *\\n     * @return Whether the drip should be executed.\\n     */\\n    function check(bytes memory _params) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xb52c89360566b2963dfd82cb2cc23f0c3ce4503a69e8563878e8aa80b6c60b3f\",\"license\":\"MIT\"},\"contracts/universal/drippie/dripchecks/CheckBalanceHigh.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.16;\\n\\nimport { IDripCheck } from \\\"../IDripCheck.sol\\\";\\n\\n/**\\n * @title CheckBalanceHigh\\n * @notice DripCheck for checking if an account's balance is above a given threshold.\\n */\\ncontract CheckBalanceHigh is IDripCheck {\\n    struct Params {\\n        address target;\\n        uint256 threshold;\\n    }\\n\\n    /**\\n     * @notice External event used to help client-side tooling encode parameters.\\n     *\\n     * @param params Parameters to encode.\\n     */\\n    event _EventToExposeStructInABI__Params(Params params);\\n\\n    /**\\n     * @inheritdoc IDripCheck\\n     */\\n    function check(bytes memory _params) external view returns (bool) {\\n        Params memory params = abi.decode(_params, (Params));\\n\\n        // Check target balance is above threshold.\\n        return params.target.balance > params.threshold;\\n    }\\n}\\n\",\"keccak256\":\"0xcb27d9e50a7c32406872b8fdc4ca62ee0d27372eb9077657f6d16f3cd3b58c85\",\"license\":\"MIT\"}},\"version\":1}",
+  "bytecode": "0x608060405234801561001057600080fd5b50610239806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c8063c64b3bb514610030575b600080fd5b61004361003e3660046100c3565b610057565b604051901515815260200160405180910390f35b6000808280602001905181019061006e9190610192565b6020810151905173ffffffffffffffffffffffffffffffffffffffff1631119392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6000602082840312156100d557600080fd5b813567ffffffffffffffff808211156100ed57600080fd5b818401915084601f83011261010157600080fd5b81358181111561011357610113610094565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f0116810190838211818310171561015957610159610094565b8160405282815287602084870101111561017257600080fd5b826020860160208301376000928101602001929092525095945050505050565b6000604082840312156101a457600080fd5b6040516040810181811067ffffffffffffffff821117156101c7576101c7610094565b604052825173ffffffffffffffffffffffffffffffffffffffff811681146101ee57600080fd5b8152602092830151928101929092525091905056fea26469706673582212203818d112b628fa60d8cffe88e7198c860e268b9375b8b118dacdbf531c397ef864736f6c63430008100033",
+  "deployedBytecode": "0x608060405234801561001057600080fd5b506004361061002b5760003560e01c8063c64b3bb514610030575b600080fd5b61004361003e3660046100c3565b610057565b604051901515815260200160405180910390f35b6000808280602001905181019061006e9190610192565b6020810151905173ffffffffffffffffffffffffffffffffffffffff1631119392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6000602082840312156100d557600080fd5b813567ffffffffffffffff808211156100ed57600080fd5b818401915084601f83011261010157600080fd5b81358181111561011357610113610094565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f0116810190838211818310171561015957610159610094565b8160405282815287602084870101111561017257600080fd5b826020860160208301376000928101602001929092525095945050505050565b6000604082840312156101a457600080fd5b6040516040810181811067ffffffffffffffff821117156101c7576101c7610094565b604052825173ffffffffffffffffffffffffffffffffffffffff811681146101ee57600080fd5b8152602092830151928101929092525091905056fea26469706673582212203818d112b628fa60d8cffe88e7198c860e268b9375b8b118dacdbf531c397ef864736f6c63430008100033",
+  "devdoc": {
+    "events": {
+      "_EventToExposeStructInABI__Params((address,uint256))": {
+        "params": {
+          "params": "Parameters to encode."
+        }
+      }
+    },
+    "kind": "dev",
+    "methods": {
+      "check(bytes)": {
+        "params": {
+          "_params": "Encoded parameters for the drip check."
+        },
+        "returns": {
+          "_0": "Whether the drip should be executed."
+        }
+      }
+    },
+    "title": "CheckBalanceHigh",
+    "version": 1
+  },
+  "userdoc": {
+    "events": {
+      "_EventToExposeStructInABI__Params((address,uint256))": {
+        "notice": "External event used to help client-side tooling encode parameters."
+      }
+    },
+    "kind": "user",
+    "methods": {
+      "check(bytes)": {
+        "notice": "Checks whether a drip should be executable."
+      }
+    },
+    "notice": "DripCheck for checking if an account's balance is above a given threshold.",
+    "version": 1
+  },
+  "storageLayout": {
+    "storage": [],
+    "types": null
+  }
+}
\ No newline at end of file

packages/contracts-periphery/deployments/goerli/CheckBalanceLow.json

+{
+  "address": "0x381a4eFC2A2C914eA1889722bB4B44Fa6BD5b640",
+  "abi": [
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "address",
+              "name": "target",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "threshold",
+              "type": "uint256"
+            }
+          ],
+          "indexed": false,
+          "internalType": "struct CheckBalanceLow.Params",
+          "name": "params",
+          "type": "tuple"
+        }
+      ],
+      "name": "_EventToExposeStructInABI__Params",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes",
+          "name": "_params",
+          "type": "bytes"
+        }
+      ],
+      "name": "check",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "transactionHash": "0x27c46f8d4f3a93eb7388ebd9be8b8c4628a30de6b358f721e810e9c881a279e5",
+  "receipt": {
+    "to": "0x4e59b44847b379578588920cA78FbF26c0B4956C",
+    "from": "0x9C6373dE60c2D3297b18A8f964618ac46E011B58",
+    "contractAddress": null,
+    "transactionIndex": 67,
+    "gasUsed": "176640",
+    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "blockHash": "0x4a6c891cb4fae11711c0494dae3ec8e90c64b1ff33e424de9db865098471e10d",
+    "transactionHash": "0x27c46f8d4f3a93eb7388ebd9be8b8c4628a30de6b358f721e810e9c881a279e5",
+    "logs": [],
+    "blockNumber": 8182667,
+    "cumulativeGasUsed": "14037277",
+    "status": 1,
+    "byzantium": true
+  },
+  "args": [],
+  "numDeployments": 1,
+  "solcInputHash": "2373b7ba869baea4fec58e6e7f7b8988",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.16+commit.07a7930e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"threshold\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"struct CheckBalanceLow.Params\",\"name\":\"params\",\"type\":\"tuple\"}],\"name\":\"_EventToExposeStructInABI__Params\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_params\",\"type\":\"bytes\"}],\"name\":\"check\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"_EventToExposeStructInABI__Params((address,uint256))\":{\"params\":{\"params\":\"Parameters to encode.\"}}},\"kind\":\"dev\",\"methods\":{\"check(bytes)\":{\"params\":{\"_params\":\"Encoded parameters for the drip check.\"},\"returns\":{\"_0\":\"Whether the drip should be executed.\"}}},\"title\":\"CheckBalanceLow\",\"version\":1},\"userdoc\":{\"events\":{\"_EventToExposeStructInABI__Params((address,uint256))\":{\"notice\":\"External event used to help client-side tooling encode parameters.\"}},\"kind\":\"user\",\"methods\":{\"check(bytes)\":{\"notice\":\"Checks whether a drip should be executable.\"}},\"notice\":\"DripCheck for checking if an account's balance is below a given threshold.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/universal/drippie/dripchecks/CheckBalanceLow.sol\":\"CheckBalanceLow\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"contracts/universal/drippie/IDripCheck.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IDripCheck {\\n    // DripCheck contracts that want to take parameters as inputs MUST expose a struct called\\n    // Params and an event _EventForExposingParamsStructInABI(Params params). This makes it\\n    // possible to easily encode parameters on the client side. Solidity does not support generics\\n    // so it's not possible to do this with explicit typing.\\n\\n    /**\\n     * @notice Checks whether a drip should be executable.\\n     *\\n     * @param _params Encoded parameters for the drip check.\\n     *\\n     * @return Whether the drip should be executed.\\n     */\\n    function check(bytes memory _params) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xb52c89360566b2963dfd82cb2cc23f0c3ce4503a69e8563878e8aa80b6c60b3f\",\"license\":\"MIT\"},\"contracts/universal/drippie/dripchecks/CheckBalanceLow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.16;\\n\\nimport { IDripCheck } from \\\"../IDripCheck.sol\\\";\\n\\n/**\\n * @title CheckBalanceLow\\n * @notice DripCheck for checking if an account's balance is below a given threshold.\\n */\\ncontract CheckBalanceLow is IDripCheck {\\n    struct Params {\\n        address target;\\n        uint256 threshold;\\n    }\\n\\n    /**\\n     * @notice External event used to help client-side tooling encode parameters.\\n     *\\n     * @param params Parameters to encode.\\n     */\\n    event _EventToExposeStructInABI__Params(Params params);\\n\\n    /**\\n     * @inheritdoc IDripCheck\\n     */\\n    function check(bytes memory _params) external view returns (bool) {\\n        Params memory params = abi.decode(_params, (Params));\\n\\n        // Check target ETH balance is below threshold.\\n        return params.target.balance < params.threshold;\\n    }\\n}\\n\",\"keccak256\":\"0x6a1187a80093770931296d3360b1ecc7d17f69157fe88f628989b257548b564b\",\"license\":\"MIT\"}},\"version\":1}",
+  "bytecode": "0x608060405234801561001057600080fd5b50610239806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c8063c64b3bb514610030575b600080fd5b61004361003e3660046100c3565b610057565b604051901515815260200160405180910390f35b6000808280602001905181019061006e9190610192565b6020810151905173ffffffffffffffffffffffffffffffffffffffff1631109392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6000602082840312156100d557600080fd5b813567ffffffffffffffff808211156100ed57600080fd5b818401915084601f83011261010157600080fd5b81358181111561011357610113610094565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f0116810190838211818310171561015957610159610094565b8160405282815287602084870101111561017257600080fd5b826020860160208301376000928101602001929092525095945050505050565b6000604082840312156101a457600080fd5b6040516040810181811067ffffffffffffffff821117156101c7576101c7610094565b604052825173ffffffffffffffffffffffffffffffffffffffff811681146101ee57600080fd5b8152602092830151928101929092525091905056fea2646970667358221220cc86d01120737597addcccffd841244801dcb64ce402d73b8d8569a52348996464736f6c63430008100033",
+  "deployedBytecode": "0x608060405234801561001057600080fd5b506004361061002b5760003560e01c8063c64b3bb514610030575b600080fd5b61004361003e3660046100c3565b610057565b604051901515815260200160405180910390f35b6000808280602001905181019061006e9190610192565b6020810151905173ffffffffffffffffffffffffffffffffffffffff1631109392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6000602082840312156100d557600080fd5b813567ffffffffffffffff808211156100ed57600080fd5b818401915084601f83011261010157600080fd5b81358181111561011357610113610094565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f0116810190838211818310171561015957610159610094565b8160405282815287602084870101111561017257600080fd5b826020860160208301376000928101602001929092525095945050505050565b6000604082840312156101a457600080fd5b6040516040810181811067ffffffffffffffff821117156101c7576101c7610094565b604052825173ffffffffffffffffffffffffffffffffffffffff811681146101ee57600080fd5b8152602092830151928101929092525091905056fea2646970667358221220cc86d01120737597addcccffd841244801dcb64ce402d73b8d8569a52348996464736f6c63430008100033",
+  "devdoc": {
+    "events": {
+      "_EventToExposeStructInABI__Params((address,uint256))": {
+        "params": {
+          "params": "Parameters to encode."
+        }
+      }
+    },
+    "kind": "dev",
+    "methods": {
+      "check(bytes)": {
+        "params": {
+          "_params": "Encoded parameters for the drip check."
+        },
+        "returns": {
+          "_0": "Whether the drip should be executed."
+        }
+      }
+    },
+    "title": "CheckBalanceLow",
+    "version": 1
+  },
+  "userdoc": {
+    "events": {
+      "_EventToExposeStructInABI__Params((address,uint256))": {
+        "notice": "External event used to help client-side tooling encode parameters."
+      }
+    },
+    "kind": "user",
+    "methods": {
+      "check(bytes)": {
+        "notice": "Checks whether a drip should be executable."
+      }
+    },
+    "notice": "DripCheck for checking if an account's balance is below a given threshold.",
+    "version": 1
+  },
+  "storageLayout": {
+    "storage": [],
+    "types": null
+  }
+}
\ No newline at end of file

packages/contracts-periphery/deployments/goerli/CheckGelatoLow.json

+{
+  "address": "0x4f7CFc43f6D262a085F3b946cAC69E7a8E39BBAa",
+  "abi": [
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "address",
+              "name": "treasury",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "threshold",
+              "type": "uint256"
+            },
+            {
+              "internalType": "address",
+              "name": "recipient",
+              "type": "address"
+            }
+          ],
+          "indexed": false,
+          "internalType": "struct CheckGelatoLow.Params",
+          "name": "params",
+          "type": "tuple"
+        }
+      ],
+      "name": "_EventToExposeStructInABI__Params",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes",
+          "name": "_params",
+          "type": "bytes"
+        }
+      ],
+      "name": "check",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "transactionHash": "0x6426a895e674bb8849028c089ed41d1b9179d8392adc9ad6d225cd53c53fe49c",
+  "receipt": {
+    "to": "0x4e59b44847b379578588920cA78FbF26c0B4956C",
+    "from": "0x9C6373dE60c2D3297b18A8f964618ac46E011B58",
+    "contractAddress": null,
+    "transactionIndex": 61,
+    "gasUsed": "222032",
+    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "blockHash": "0x4b8ed6e59a8559084820c6f9514b9ddec7de519cbf6940131b43f939c63c4307",
+    "transactionHash": "0x6426a895e674bb8849028c089ed41d1b9179d8392adc9ad6d225cd53c53fe49c",
+    "logs": [],
+    "blockNumber": 8182670,
+    "cumulativeGasUsed": "12472395",
+    "status": 1,
+    "byzantium": true
+  },
+  "args": [],
+  "numDeployments": 1,
+  "solcInputHash": "2373b7ba869baea4fec58e6e7f7b8988",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.16+commit.07a7930e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"treasury\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"threshold\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"indexed\":false,\"internalType\":\"struct CheckGelatoLow.Params\",\"name\":\"params\",\"type\":\"tuple\"}],\"name\":\"_EventToExposeStructInABI__Params\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_params\",\"type\":\"bytes\"}],\"name\":\"check\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"_EventToExposeStructInABI__Params((address,uint256,address))\":{\"params\":{\"params\":\"Parameters to encode.\"}}},\"kind\":\"dev\",\"methods\":{\"check(bytes)\":{\"params\":{\"_params\":\"Encoded parameters for the drip check.\"},\"returns\":{\"_0\":\"Whether the drip should be executed.\"}}},\"title\":\"CheckGelatoLow\",\"version\":1},\"userdoc\":{\"events\":{\"_EventToExposeStructInABI__Params((address,uint256,address))\":{\"notice\":\"External event used to help client-side tooling encode parameters.\"}},\"kind\":\"user\",\"methods\":{\"check(bytes)\":{\"notice\":\"Checks whether a drip should be executable.\"}},\"notice\":\"DripCheck for checking if an account's Gelato ETH balance is below some threshold.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/universal/drippie/dripchecks/CheckGelatoLow.sol\":\"CheckGelatoLow\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"contracts/universal/drippie/IDripCheck.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IDripCheck {\\n    // DripCheck contracts that want to take parameters as inputs MUST expose a struct called\\n    // Params and an event _EventForExposingParamsStructInABI(Params params). This makes it\\n    // possible to easily encode parameters on the client side. Solidity does not support generics\\n    // so it's not possible to do this with explicit typing.\\n\\n    /**\\n     * @notice Checks whether a drip should be executable.\\n     *\\n     * @param _params Encoded parameters for the drip check.\\n     *\\n     * @return Whether the drip should be executed.\\n     */\\n    function check(bytes memory _params) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xb52c89360566b2963dfd82cb2cc23f0c3ce4503a69e8563878e8aa80b6c60b3f\",\"license\":\"MIT\"},\"contracts/universal/drippie/dripchecks/CheckGelatoLow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.16;\\n\\nimport { IDripCheck } from \\\"../IDripCheck.sol\\\";\\n\\ninterface IGelatoTreasury {\\n    function userTokenBalance(address _user, address _token) external view returns (uint256);\\n}\\n\\n/**\\n * @title CheckGelatoLow\\n * @notice DripCheck for checking if an account's Gelato ETH balance is below some threshold.\\n */\\ncontract CheckGelatoLow is IDripCheck {\\n    struct Params {\\n        address treasury;\\n        uint256 threshold;\\n        address recipient;\\n    }\\n\\n    /**\\n     * @notice External event used to help client-side tooling encode parameters.\\n     *\\n     * @param params Parameters to encode.\\n     */\\n    event _EventToExposeStructInABI__Params(Params params);\\n\\n    /**\\n     * @inheritdoc IDripCheck\\n     */\\n    function check(bytes memory _params) external view returns (bool) {\\n        Params memory params = abi.decode(_params, (Params));\\n\\n        // Check GelatoTreasury ETH balance is below threshold.\\n        return\\n            IGelatoTreasury(params.treasury).userTokenBalance(\\n                params.recipient,\\n                // Gelato represents ETH as 0xeeeee....eeeee\\n                0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE\\n            ) < params.threshold;\\n    }\\n}\\n\",\"keccak256\":\"0x1a127a2c8955525cc2e5cd3c6703edc785c662a79222f524df4574cf47ddd864\",\"license\":\"MIT\"}},\"version\":1}",
+  "bytecode": "0x608060405234801561001057600080fd5b5061030c806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c8063c64b3bb514610030575b600080fd5b61004361003e366004610160565b610057565b604051901515815260200160405180910390f35b6000808280602001905181019061006e9190610258565b6020810151815160408084015190517fb47064c800000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff918216600482015273eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee6024820152939450919291169063b47064c890604401602060405180830381865afa158015610105573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061012991906102bd565b109392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60006020828403121561017257600080fd5b813567ffffffffffffffff8082111561018a57600080fd5b818401915084601f83011261019e57600080fd5b8135818111156101b0576101b0610131565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f011681019083821181831017156101f6576101f6610131565b8160405282815287602084870101111561020f57600080fd5b826020860160208301376000928101602001929092525095945050505050565b805173ffffffffffffffffffffffffffffffffffffffff8116811461025357600080fd5b919050565b60006060828403121561026a57600080fd5b6040516060810181811067ffffffffffffffff8211171561028d5761028d610131565b6040526102998361022f565b8152602083015160208201526102b16040840161022f565b60408201529392505050565b6000602082840312156102cf57600080fd5b505191905056fea2646970667358221220d5d7b760af134f89109f20dbf88fd89e78bb4b81bed97f9aa45772b3775b388964736f6c63430008100033",
+  "deployedBytecode": "0x608060405234801561001057600080fd5b506004361061002b5760003560e01c8063c64b3bb514610030575b600080fd5b61004361003e366004610160565b610057565b604051901515815260200160405180910390f35b6000808280602001905181019061006e9190610258565b6020810151815160408084015190517fb47064c800000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff918216600482015273eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee6024820152939450919291169063b47064c890604401602060405180830381865afa158015610105573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061012991906102bd565b109392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60006020828403121561017257600080fd5b813567ffffffffffffffff8082111561018a57600080fd5b818401915084601f83011261019e57600080fd5b8135818111156101b0576101b0610131565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f011681019083821181831017156101f6576101f6610131565b8160405282815287602084870101111561020f57600080fd5b826020860160208301376000928101602001929092525095945050505050565b805173ffffffffffffffffffffffffffffffffffffffff8116811461025357600080fd5b919050565b60006060828403121561026a57600080fd5b6040516060810181811067ffffffffffffffff8211171561028d5761028d610131565b6040526102998361022f565b8152602083015160208201526102b16040840161022f565b60408201529392505050565b6000602082840312156102cf57600080fd5b505191905056fea2646970667358221220d5d7b760af134f89109f20dbf88fd89e78bb4b81bed97f9aa45772b3775b388964736f6c63430008100033",
+  "devdoc": {
+    "events": {
+      "_EventToExposeStructInABI__Params((address,uint256,address))": {
+        "params": {
+          "params": "Parameters to encode."
+        }
+      }
+    },
+    "kind": "dev",
+    "methods": {
+      "check(bytes)": {
+        "params": {
+          "_params": "Encoded parameters for the drip check."
+        },
+        "returns": {
+          "_0": "Whether the drip should be executed."
+        }
+      }
+    },
+    "title": "CheckGelatoLow",
+    "version": 1
+  },
+  "userdoc": {
+    "events": {
+      "_EventToExposeStructInABI__Params((address,uint256,address))": {
+        "notice": "External event used to help client-side tooling encode parameters."
+      }
+    },
+    "kind": "user",
+    "methods": {
+      "check(bytes)": {
+        "notice": "Checks whether a drip should be executable."
+      }
+    },
+    "notice": "DripCheck for checking if an account's Gelato ETH balance is below some threshold.",
+    "version": 1
+  },
+  "storageLayout": {
+    "storage": [],
+    "types": null
+  }
+}
\ No newline at end of file

packages/contracts-periphery/deployments/goerli/CheckTrue.json

+{
+  "address": "0x5c741a38cb11424711231777D71689C458eE835D",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "name": "check",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    }
+  ],
+  "transactionHash": "0xeacb73acd8f3d741e1a4a136e95cec43d21aef36b95611cdaa86c87066bfd087",
+  "receipt": {
+    "to": "0x4e59b44847b379578588920cA78FbF26c0B4956C",
+    "from": "0x9C6373dE60c2D3297b18A8f964618ac46E011B58",
+    "contractAddress": null,
+    "transactionIndex": 81,
+    "gasUsed": "139230",
+    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "blockHash": "0x396e72234d59683880032c4c9e6fd61a46b839b61c644c7bd180e02d565c3b14",
+    "transactionHash": "0xeacb73acd8f3d741e1a4a136e95cec43d21aef36b95611cdaa86c87066bfd087",
+    "logs": [],
+    "blockNumber": 8182671,
+    "cumulativeGasUsed": "17047212",
+    "status": 1,
+    "byzantium": true
+  },
+  "args": [],
+  "numDeployments": 1,
+  "solcInputHash": "2373b7ba869baea4fec58e6e7f7b8988",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.16+commit.07a7930e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"check\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"check(bytes)\":{\"params\":{\"_params\":\"Encoded parameters for the drip check.\"},\"returns\":{\"_0\":\"Whether the drip should be executed.\"}}},\"title\":\"CheckTrue\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"check(bytes)\":{\"notice\":\"Checks whether a drip should be executable.\"}},\"notice\":\"DripCheck that always returns true.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/universal/drippie/dripchecks/CheckTrue.sol\":\"CheckTrue\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"contracts/universal/drippie/IDripCheck.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IDripCheck {\\n    // DripCheck contracts that want to take parameters as inputs MUST expose a struct called\\n    // Params and an event _EventForExposingParamsStructInABI(Params params). This makes it\\n    // possible to easily encode parameters on the client side. Solidity does not support generics\\n    // so it's not possible to do this with explicit typing.\\n\\n    /**\\n     * @notice Checks whether a drip should be executable.\\n     *\\n     * @param _params Encoded parameters for the drip check.\\n     *\\n     * @return Whether the drip should be executed.\\n     */\\n    function check(bytes memory _params) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xb52c89360566b2963dfd82cb2cc23f0c3ce4503a69e8563878e8aa80b6c60b3f\",\"license\":\"MIT\"},\"contracts/universal/drippie/dripchecks/CheckTrue.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.16;\\n\\nimport { IDripCheck } from \\\"../IDripCheck.sol\\\";\\n\\n/**\\n * @title CheckTrue\\n * @notice DripCheck that always returns true.\\n */\\ncontract CheckTrue is IDripCheck {\\n    /**\\n     * @inheritdoc IDripCheck\\n     */\\n    function check(bytes memory) external pure returns (bool) {\\n        return true;\\n    }\\n}\\n\",\"keccak256\":\"0xf2f5474f12983c30ca4fe9d19e7f88e6d2262e4a6f779e86b4a2117498fdbea5\",\"license\":\"MIT\"}},\"version\":1}",
+  "bytecode": "0x608060405234801561001057600080fd5b5061018c806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c8063c64b3bb514610030575b600080fd5b61004461003e366004610087565b50600190565b604051901515815260200160405180910390f35b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60006020828403121561009957600080fd5b813567ffffffffffffffff808211156100b157600080fd5b818401915084601f8301126100c557600080fd5b8135818111156100d7576100d7610058565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f0116810190838211818310171561011d5761011d610058565b8160405282815287602084870101111561013657600080fd5b82602086016020830137600092810160200192909252509594505050505056fea26469706673582212200bb899cb0e5f9dce180ebe72a1dfade46ffc5ec3cab398d1f2af09e8b9ce76d164736f6c63430008100033",
+  "deployedBytecode": "0x608060405234801561001057600080fd5b506004361061002b5760003560e01c8063c64b3bb514610030575b600080fd5b61004461003e366004610087565b50600190565b604051901515815260200160405180910390f35b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60006020828403121561009957600080fd5b813567ffffffffffffffff808211156100b157600080fd5b818401915084601f8301126100c557600080fd5b8135818111156100d7576100d7610058565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f0116810190838211818310171561011d5761011d610058565b8160405282815287602084870101111561013657600080fd5b82602086016020830137600092810160200192909252509594505050505056fea26469706673582212200bb899cb0e5f9dce180ebe72a1dfade46ffc5ec3cab398d1f2af09e8b9ce76d164736f6c63430008100033",
+  "devdoc": {
+    "kind": "dev",
+    "methods": {
+      "check(bytes)": {
+        "params": {
+          "_params": "Encoded parameters for the drip check."
+        },
+        "returns": {
+          "_0": "Whether the drip should be executed."
+        }
+      }
+    },
+    "title": "CheckTrue",
+    "version": 1
+  },
+  "userdoc": {
+    "kind": "user",
+    "methods": {
+      "check(bytes)": {
+        "notice": "Checks whether a drip should be executable."
+      }
+    },
+    "notice": "DripCheck that always returns true.",
+    "version": 1
+  },
+  "storageLayout": {
+    "storage": [],
+    "types": null
+  }
+}
\ No newline at end of file

packages/contracts-periphery/deployments/goerli/solcInputs/2373b7ba869baea4fec58e6e7f7b8988.json

+{
+  "language": "Solidity",
+  "sources": {
+    "contracts/testing/helpers/TestERC20.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ERC20 } from \"@rari-capital/solmate/src/tokens/ERC20.sol\";\n\ncontract TestERC20 is ERC20 {\n    constructor() ERC20(\"TEST\", \"TST\", 18) {}\n\n    function mint(address to, uint256 value) public {\n        _mint(to, value);\n    }\n}\n"
+    },
+    "@rari-capital/solmate/src/tokens/ERC20.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.0;\n\n/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.\n/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)\n/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.\nabstract contract ERC20 {\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    event Transfer(address indexed from, address indexed to, uint256 amount);\n\n    event Approval(address indexed owner, address indexed spender, uint256 amount);\n\n    /*//////////////////////////////////////////////////////////////\n                            METADATA STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    string public name;\n\n    string public symbol;\n\n    uint8 public immutable decimals;\n\n    /*//////////////////////////////////////////////////////////////\n                              ERC20 STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    uint256 public totalSupply;\n\n    mapping(address => uint256) public balanceOf;\n\n    mapping(address => mapping(address => uint256)) public allowance;\n\n    /*//////////////////////////////////////////////////////////////\n                            EIP-2612 STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    uint256 internal immutable INITIAL_CHAIN_ID;\n\n    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;\n\n    mapping(address => uint256) public nonces;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTRUCTOR\n    //////////////////////////////////////////////////////////////*/\n\n    constructor(\n        string memory _name,\n        string memory _symbol,\n        uint8 _decimals\n    ) {\n        name = _name;\n        symbol = _symbol;\n        decimals = _decimals;\n\n        INITIAL_CHAIN_ID = block.chainid;\n        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               ERC20 LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function approve(address spender, uint256 amount) public virtual returns (bool) {\n        allowance[msg.sender][spender] = amount;\n\n        emit Approval(msg.sender, spender, amount);\n\n        return true;\n    }\n\n    function transfer(address to, uint256 amount) public virtual returns (bool) {\n        balanceOf[msg.sender] -= amount;\n\n        // Cannot overflow because the sum of all user\n        // balances can't exceed the max uint256 value.\n        unchecked {\n            balanceOf[to] += amount;\n        }\n\n        emit Transfer(msg.sender, to, amount);\n\n        return true;\n    }\n\n    function transferFrom(\n        address from,\n        address to,\n        uint256 amount\n    ) public virtual returns (bool) {\n        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.\n\n        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;\n\n        balanceOf[from] -= amount;\n\n        // Cannot overflow because the sum of all user\n        // balances can't exceed the max uint256 value.\n        unchecked {\n            balanceOf[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        return true;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                             EIP-2612 LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        require(deadline >= block.timestamp, \"PERMIT_DEADLINE_EXPIRED\");\n\n        // Unchecked because the only math done is incrementing\n        // the owner's nonce which cannot realistically overflow.\n        unchecked {\n            address recoveredAddress = ecrecover(\n                keccak256(\n                    abi.encodePacked(\n                        \"\\x19\\x01\",\n                        DOMAIN_SEPARATOR(),\n                        keccak256(\n                            abi.encode(\n                                keccak256(\n                                    \"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\"\n                                ),\n                                owner,\n                                spender,\n                                value,\n                                nonces[owner]++,\n                                deadline\n                            )\n                        )\n                    )\n                ),\n                v,\n                r,\n                s\n            );\n\n            require(recoveredAddress != address(0) && recoveredAddress == owner, \"INVALID_SIGNER\");\n\n            allowance[recoveredAddress][spender] = value;\n        }\n\n        emit Approval(owner, spender, value);\n    }\n\n    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {\n        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();\n    }\n\n    function computeDomainSeparator() internal view virtual returns (bytes32) {\n        return\n            keccak256(\n                abi.encode(\n                    keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n                    keccak256(bytes(name)),\n                    keccak256(\"1\"),\n                    block.chainid,\n                    address(this)\n                )\n            );\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                        INTERNAL MINT/BURN LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function _mint(address to, uint256 amount) internal virtual {\n        totalSupply += amount;\n\n        // Cannot overflow because the sum of all user\n        // balances can't exceed the max uint256 value.\n        unchecked {\n            balanceOf[to] += amount;\n        }\n\n        emit Transfer(address(0), to, amount);\n    }\n\n    function _burn(address from, uint256 amount) internal virtual {\n        balanceOf[from] -= amount;\n\n        // Cannot underflow because a user's balance\n        // will never be larger than the total supply.\n        unchecked {\n            totalSupply -= amount;\n        }\n\n        emit Transfer(from, address(0), amount);\n    }\n}\n"
+    },
+    "contracts/universal/AssetReceiver.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ERC20 } from \"@rari-capital/solmate/src/tokens/ERC20.sol\";\nimport { ERC721 } from \"@rari-capital/solmate/src/tokens/ERC721.sol\";\nimport { Transactor } from \"./Transactor.sol\";\n\n/**\n * @title AssetReceiver\n * @notice AssetReceiver is a minimal contract for receiving funds assets in the form of either\n * ETH, ERC20 tokens, or ERC721 tokens. Only the contract owner may withdraw the assets.\n */\ncontract AssetReceiver is Transactor {\n    /**\n     * @notice Emitted when ETH is received by this address.\n     *\n     * @param from   Address that sent ETH to this contract.\n     * @param amount Amount of ETH received.\n     */\n    event ReceivedETH(address indexed from, uint256 amount);\n\n    /**\n     * @notice Emitted when ETH is withdrawn from this address.\n     *\n     * @param withdrawer Address that triggered the withdrawal.\n     * @param recipient  Address that received the withdrawal.\n     * @param amount     ETH amount withdrawn.\n     */\n    event WithdrewETH(address indexed withdrawer, address indexed recipient, uint256 amount);\n\n    /**\n     * @notice Emitted when ERC20 tokens are withdrawn from this address.\n     *\n     * @param withdrawer Address that triggered the withdrawal.\n     * @param recipient  Address that received the withdrawal.\n     * @param asset      Address of the token being withdrawn.\n     * @param amount     ERC20 amount withdrawn.\n     */\n    event WithdrewERC20(\n        address indexed withdrawer,\n        address indexed recipient,\n        address indexed asset,\n        uint256 amount\n    );\n\n    /**\n     * @notice Emitted when ERC20 tokens are withdrawn from this address.\n     *\n     * @param withdrawer Address that triggered the withdrawal.\n     * @param recipient  Address that received the withdrawal.\n     * @param asset      Address of the token being withdrawn.\n     * @param id         Token ID being withdrawn.\n     */\n    event WithdrewERC721(\n        address indexed withdrawer,\n        address indexed recipient,\n        address indexed asset,\n        uint256 id\n    );\n\n    /**\n     * @param _owner Initial contract owner.\n     */\n    constructor(address _owner) Transactor(_owner) {}\n\n    /**\n     * @notice Make sure we can receive ETH.\n     */\n    receive() external payable {\n        emit ReceivedETH(msg.sender, msg.value);\n    }\n\n    /**\n     * @notice Withdraws full ETH balance to the recipient.\n     *\n     * @param _to Address to receive the ETH balance.\n     */\n    function withdrawETH(address payable _to) external onlyOwner {\n        withdrawETH(_to, address(this).balance);\n    }\n\n    /**\n     * @notice Withdraws partial ETH balance to the recipient.\n     *\n     * @param _to     Address to receive the ETH balance.\n     * @param _amount Amount of ETH to withdraw.\n     */\n    function withdrawETH(address payable _to, uint256 _amount) public onlyOwner {\n        // slither-disable-next-line reentrancy-unlimited-gas\n        (bool success, ) = _to.call{ value: _amount }(\"\");\n        emit WithdrewETH(msg.sender, _to, _amount);\n    }\n\n    /**\n     * @notice Withdraws full ERC20 balance to the recipient.\n     *\n     * @param _asset ERC20 token to withdraw.\n     * @param _to    Address to receive the ERC20 balance.\n     */\n    function withdrawERC20(ERC20 _asset, address _to) external onlyOwner {\n        withdrawERC20(_asset, _to, _asset.balanceOf(address(this)));\n    }\n\n    /**\n     * @notice Withdraws partial ERC20 balance to the recipient.\n     *\n     * @param _asset  ERC20 token to withdraw.\n     * @param _to     Address to receive the ERC20 balance.\n     * @param _amount Amount of ERC20 to withdraw.\n     */\n    function withdrawERC20(\n        ERC20 _asset,\n        address _to,\n        uint256 _amount\n    ) public onlyOwner {\n        // slither-disable-next-line unchecked-transfer\n        _asset.transfer(_to, _amount);\n        // slither-disable-next-line reentrancy-events\n        emit WithdrewERC20(msg.sender, _to, address(_asset), _amount);\n    }\n\n    /**\n     * @notice Withdraws ERC721 token to the recipient.\n     *\n     * @param _asset ERC721 token to withdraw.\n     * @param _to    Address to receive the ERC721 token.\n     * @param _id    Token ID of the ERC721 token to withdraw.\n     */\n    function withdrawERC721(\n        ERC721 _asset,\n        address _to,\n        uint256 _id\n    ) external onlyOwner {\n        _asset.transferFrom(address(this), _to, _id);\n        // slither-disable-next-line reentrancy-events\n        emit WithdrewERC721(msg.sender, _to, address(_asset), _id);\n    }\n}\n"
+    },
+    "@rari-capital/solmate/src/tokens/ERC721.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.0;\n\n/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.\n/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)\nabstract contract ERC721 {\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    event Transfer(address indexed from, address indexed to, uint256 indexed id);\n\n    event Approval(address indexed owner, address indexed spender, uint256 indexed id);\n\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /*//////////////////////////////////////////////////////////////\n                         METADATA STORAGE/LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    string public name;\n\n    string public symbol;\n\n    function tokenURI(uint256 id) public view virtual returns (string memory);\n\n    /*//////////////////////////////////////////////////////////////\n                      ERC721 BALANCE/OWNER STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    mapping(uint256 => address) internal _ownerOf;\n\n    mapping(address => uint256) internal _balanceOf;\n\n    function ownerOf(uint256 id) public view virtual returns (address owner) {\n        require((owner = _ownerOf[id]) != address(0), \"NOT_MINTED\");\n    }\n\n    function balanceOf(address owner) public view virtual returns (uint256) {\n        require(owner != address(0), \"ZERO_ADDRESS\");\n\n        return _balanceOf[owner];\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                         ERC721 APPROVAL STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    mapping(uint256 => address) public getApproved;\n\n    mapping(address => mapping(address => bool)) public isApprovedForAll;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTRUCTOR\n    //////////////////////////////////////////////////////////////*/\n\n    constructor(string memory _name, string memory _symbol) {\n        name = _name;\n        symbol = _symbol;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                              ERC721 LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function approve(address spender, uint256 id) public virtual {\n        address owner = _ownerOf[id];\n\n        require(msg.sender == owner || isApprovedForAll[owner][msg.sender], \"NOT_AUTHORIZED\");\n\n        getApproved[id] = spender;\n\n        emit Approval(owner, spender, id);\n    }\n\n    function setApprovalForAll(address operator, bool approved) public virtual {\n        isApprovedForAll[msg.sender][operator] = approved;\n\n        emit ApprovalForAll(msg.sender, operator, approved);\n    }\n\n    function transferFrom(\n        address from,\n        address to,\n        uint256 id\n    ) public virtual {\n        require(from == _ownerOf[id], \"WRONG_FROM\");\n\n        require(to != address(0), \"INVALID_RECIPIENT\");\n\n        require(\n            msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id],\n            \"NOT_AUTHORIZED\"\n        );\n\n        // Underflow of the sender's balance is impossible because we check for\n        // ownership above and the recipient's balance can't realistically overflow.\n        unchecked {\n            _balanceOf[from]--;\n\n            _balanceOf[to]++;\n        }\n\n        _ownerOf[id] = to;\n\n        delete getApproved[id];\n\n        emit Transfer(from, to, id);\n    }\n\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 id\n    ) public virtual {\n        transferFrom(from, to, id);\n\n        if (to.code.length != 0)\n            require(\n                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, \"\") ==\n                    ERC721TokenReceiver.onERC721Received.selector,\n                \"UNSAFE_RECIPIENT\"\n            );\n    }\n\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 id,\n        bytes calldata data\n    ) public virtual {\n        transferFrom(from, to, id);\n\n        if (to.code.length != 0)\n            require(\n                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==\n                    ERC721TokenReceiver.onERC721Received.selector,\n                \"UNSAFE_RECIPIENT\"\n            );\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                              ERC165 LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return\n            interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165\n            interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721\n            interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                        INTERNAL MINT/BURN LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function _mint(address to, uint256 id) internal virtual {\n        require(to != address(0), \"INVALID_RECIPIENT\");\n\n        require(_ownerOf[id] == address(0), \"ALREADY_MINTED\");\n\n        // Counter overflow is incredibly unrealistic.\n        unchecked {\n            _balanceOf[to]++;\n        }\n\n        _ownerOf[id] = to;\n\n        emit Transfer(address(0), to, id);\n    }\n\n    function _burn(uint256 id) internal virtual {\n        address owner = _ownerOf[id];\n\n        require(owner != address(0), \"NOT_MINTED\");\n\n        // Ownership check above ensures no underflow.\n        unchecked {\n            _balanceOf[owner]--;\n        }\n\n        delete _ownerOf[id];\n\n        delete getApproved[id];\n\n        emit Transfer(owner, address(0), id);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                        INTERNAL SAFE MINT LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function _safeMint(address to, uint256 id) internal virtual {\n        _mint(to, id);\n\n        if (to.code.length != 0)\n            require(\n                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, \"\") ==\n                    ERC721TokenReceiver.onERC721Received.selector,\n                \"UNSAFE_RECIPIENT\"\n            );\n    }\n\n    function _safeMint(\n        address to,\n        uint256 id,\n        bytes memory data\n    ) internal virtual {\n        _mint(to, id);\n\n        if (to.code.length != 0)\n            require(\n                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==\n                    ERC721TokenReceiver.onERC721Received.selector,\n                \"UNSAFE_RECIPIENT\"\n            );\n    }\n}\n\n/// @notice A generic interface for a contract which properly accepts ERC721 tokens.\n/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)\nabstract contract ERC721TokenReceiver {\n    function onERC721Received(\n        address,\n        address,\n        uint256,\n        bytes calldata\n    ) external virtual returns (bytes4) {\n        return ERC721TokenReceiver.onERC721Received.selector;\n    }\n}\n"
+    },
+    "contracts/universal/Transactor.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { Owned } from \"@rari-capital/solmate/src/auth/Owned.sol\";\n\n/**\n * @title Transactor\n * @notice Transactor is a minimal contract that can send transactions.\n */\ncontract Transactor is Owned {\n    /**\n     * @param _owner Initial contract owner.\n     */\n    constructor(address _owner) Owned(_owner) {}\n\n    /**\n     * Sends a CALL to a target address.\n     *\n     * @param _target Address to call.\n     * @param _data   Data to send with the call.\n     * @param _value  ETH value to send with the call.\n     *\n     * @return Boolean success value.\n     * @return Bytes data returned by the call.\n     */\n    function CALL(\n        address _target,\n        bytes memory _data,\n        uint256 _value\n    ) external payable onlyOwner returns (bool, bytes memory) {\n        return _target.call{ value: _value }(_data);\n    }\n\n    /**\n     * Sends a DELEGATECALL to a target address.\n     *\n     * @param _target Address to call.\n     * @param _data   Data to send with the call.\n     *\n     * @return Boolean success value.\n     * @return Bytes data returned by the call.\n     */\n    function DELEGATECALL(address _target, bytes memory _data)\n        external\n        payable\n        onlyOwner\n        returns (bool, bytes memory)\n    {\n        // slither-disable-next-line controlled-delegatecall\n        return _target.delegatecall(_data);\n    }\n}\n"
+    },
+    "@rari-capital/solmate/src/auth/Owned.sol": {
+      "content": "// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity >=0.8.0;\n\n/// @notice Simple single owner authorization mixin.\n/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/auth/Owned.sol)\nabstract contract Owned {\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    event OwnerUpdated(address indexed user, address indexed newOwner);\n\n    /*//////////////////////////////////////////////////////////////\n                            OWNERSHIP STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    address public owner;\n\n    modifier onlyOwner() virtual {\n        require(msg.sender == owner, \"UNAUTHORIZED\");\n\n        _;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTRUCTOR\n    //////////////////////////////////////////////////////////////*/\n\n    constructor(address _owner) {\n        owner = _owner;\n\n        emit OwnerUpdated(address(0), _owner);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                             OWNERSHIP LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function setOwner(address newOwner) public virtual onlyOwner {\n        owner = newOwner;\n\n        emit OwnerUpdated(msg.sender, newOwner);\n    }\n}\n"
+    },
+    "contracts/universal/drippie/Drippie.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { AssetReceiver } from \"../AssetReceiver.sol\";\nimport { IDripCheck } from \"./IDripCheck.sol\";\n\n/**\n * @title Drippie\n * @notice Drippie is a system for managing automated contract interactions. A specific interaction\n *         is called a \"drip\" and can be executed according to some condition (called a dripcheck)\n *         and an execution interval. Drips cannot be executed faster than the execution interval.\n *         Drips can trigger arbitrary contract calls where the calling contract is this contract\n *         address. Drips can also send ETH value, which makes them ideal for keeping addresses\n *         sufficiently funded with ETH. Drippie is designed to be connected with smart contract\n *         automation services so that drips can be executed automatically. However, Drippie is\n *         specifically designed to be separated from these services so that trust assumptions are\n *         better compartmentalized.\n */\ncontract Drippie is AssetReceiver {\n    /**\n     * @notice Enum representing different status options for a given drip.\n     *\n     * @custom:value NONE     Drip does not exist.\n     * @custom:value PAUSED   Drip is paused and cannot be executed until reactivated.\n     * @custom:value ACTIVE   Drip is active and can be executed.\n     * @custom:value ARCHIVED Drip is archived and can no longer be executed or reactivated.\n     */\n    enum DripStatus {\n        NONE,\n        PAUSED,\n        ACTIVE,\n        ARCHIVED\n    }\n\n    /**\n     * @notice Represents a drip action.\n     */\n    struct DripAction {\n        address payable target;\n        bytes data;\n        uint256 value;\n    }\n\n    /**\n     * @notice Represents the configuration for a given drip.\n     */\n    struct DripConfig {\n        bool reentrant;\n        uint256 interval;\n        IDripCheck dripcheck;\n        bytes checkparams;\n        DripAction[] actions;\n    }\n\n    /**\n     * @notice Represents the state of an active drip.\n     */\n    struct DripState {\n        DripStatus status;\n        DripConfig config;\n        uint256 last;\n        uint256 count;\n    }\n\n    /**\n     * @notice Emitted when a new drip is created.\n     *\n     * @param nameref Indexed name parameter (hashed).\n     * @param name    Unindexed name parameter (unhashed).\n     * @param config  Config for the created drip.\n     */\n    event DripCreated(\n        // Emit name twice because indexed version is hashed.\n        string indexed nameref,\n        string name,\n        DripConfig config\n    );\n\n    /**\n     * @notice Emitted when a drip status is updated.\n     *\n     * @param nameref Indexed name parameter (hashed).\n     * @param name    Unindexed name parameter (unhashed).\n     * @param status  New drip status.\n     */\n    event DripStatusUpdated(\n        // Emit name twice because indexed version is hashed.\n        string indexed nameref,\n        string name,\n        DripStatus status\n    );\n\n    /**\n     * @notice Emitted when a drip is executed.\n     *\n     * @param nameref   Indexed name parameter (hashed).\n     * @param name      Unindexed name parameter (unhashed).\n     * @param executor  Address that executed the drip.\n     * @param timestamp Time when the drip was executed.\n     */\n    event DripExecuted(\n        // Emit name twice because indexed version is hashed.\n        string indexed nameref,\n        string name,\n        address executor,\n        uint256 timestamp\n    );\n\n    /**\n     * @notice Maps from drip names to drip states.\n     */\n    mapping(string => DripState) public drips;\n\n    /**\n     * @param _owner Initial contract owner.\n     */\n    constructor(address _owner) AssetReceiver(_owner) {}\n\n    /**\n     * @notice Creates a new drip with the given name and configuration. Once created, drips cannot\n     *         be modified in any way (this is a security measure). If you want to update a drip,\n     *         simply pause (and potentially archive) the existing drip and create a new one.\n     *\n     * @param _name   Name of the drip.\n     * @param _config Configuration for the drip.\n     */\n    function create(string calldata _name, DripConfig calldata _config) external onlyOwner {\n        // Make sure this drip doesn't already exist. We *must* guarantee that no other function\n        // will ever set the status of a drip back to NONE after it's been created. This is why\n        // archival is a separate status.\n        require(\n            drips[_name].status == DripStatus.NONE,\n            \"Drippie: drip with that name already exists\"\n        );\n\n        // Validate the drip interval, only allowing an interval of zero if the drip has explicitly\n        // been marked as reentrant. Prevents client-side bugs making a drip infinitely executable\n        // within the same block (of course, restricted by gas limits).\n        if (_config.reentrant) {\n            require(\n                _config.interval == 0,\n                \"Drippie: if allowing reentrant drip, must set interval to zero\"\n            );\n        } else {\n            require(\n                _config.interval > 0,\n                \"Drippie: interval must be greater than zero if drip is not reentrant\"\n            );\n        }\n\n        // We initialize this way because Solidity won't let us copy arrays into storage yet.\n        DripState storage state = drips[_name];\n        state.status = DripStatus.PAUSED;\n        state.config.reentrant = _config.reentrant;\n        state.config.interval = _config.interval;\n        state.config.dripcheck = _config.dripcheck;\n        state.config.checkparams = _config.checkparams;\n\n        // Solidity doesn't let us copy arrays into storage, so we push each array one by one.\n        for (uint256 i = 0; i < _config.actions.length; i++) {\n            state.config.actions.push(_config.actions[i]);\n        }\n\n        // Tell the world!\n        emit DripCreated(_name, _name, _config);\n    }\n\n    /**\n     * @notice Sets the status for a given drip. The behavior of this function depends on the\n     *         status that the user is trying to set. A drip can always move between ACTIVE and\n     *         PAUSED, but it can never move back to NONE and once ARCHIVED, it can never move back\n     *         to ACTIVE or PAUSED.\n     *\n     * @param _name   Name of the drip to update.\n     * @param _status New drip status.\n     */\n    function status(string calldata _name, DripStatus _status) external onlyOwner {\n        // Make sure we can never set drip status back to NONE. A simple security measure to\n        // prevent accidental overwrites if this code is ever updated down the line.\n        require(\n            _status != DripStatus.NONE,\n            \"Drippie: drip status can never be set back to NONE after creation\"\n        );\n\n        // Load the drip status once to avoid unnecessary SLOADs.\n        DripStatus curr = drips[_name].status;\n\n        // Make sure the drip in question actually exists. Not strictly necessary but there doesn't\n        // seem to be any clear reason why you would want to do this, and it may save some gas in\n        // the case of a front-end bug.\n        require(\n            curr != DripStatus.NONE,\n            \"Drippie: drip with that name does not exist and cannot be updated\"\n        );\n\n        // Once a drip has been archived, it cannot be un-archived. This is, after all, the entire\n        // point of archiving a drip.\n        require(\n            curr != DripStatus.ARCHIVED,\n            \"Drippie: drip with that name has been archived and cannot be updated\"\n        );\n\n        // Although not strictly necessary, we make sure that the status here is actually changing.\n        // This may save the client some gas if there's a front-end bug and the user accidentally\n        // tries to \"change\" the status to the same value as before.\n        require(\n            curr != _status,\n            \"Drippie: cannot set drip status to the same status as its current status\"\n        );\n\n        // If the user is trying to archive this drip, make sure the drip has been paused. We do\n        // not allow users to archive active drips so that the effects of this action are more\n        // abundantly clear.\n        if (_status == DripStatus.ARCHIVED) {\n            require(\n                curr == DripStatus.PAUSED,\n                \"Drippie: drip must first be paused before being archived\"\n            );\n        }\n\n        // If we made it here then we can safely update the status.\n        drips[_name].status = _status;\n        emit DripStatusUpdated(_name, _name, _status);\n    }\n\n    /**\n     * @notice Checks if a given drip is executable.\n     *\n     * @param _name Drip to check.\n     *\n     * @return True if the drip is executable, reverts otherwise.\n     */\n    function executable(string calldata _name) public view returns (bool) {\n        DripState storage state = drips[_name];\n\n        // Only allow active drips to be executed, an obvious security measure.\n        require(\n            state.status == DripStatus.ACTIVE,\n            \"Drippie: selected drip does not exist or is not currently active\"\n        );\n\n        // Don't drip if the drip interval has not yet elapsed since the last time we dripped. This\n        // is a safety measure that prevents a malicious recipient from, e.g., spending all of\n        // their funds and repeatedly requesting new drips. Limits the potential impact of a\n        // compromised recipient to just a single drip interval, after which the drip can be paused\n        // by the owner address.\n        require(\n            state.last + state.config.interval <= block.timestamp,\n            \"Drippie: drip interval has not elapsed since last drip\"\n        );\n\n        // Make sure we're allowed to execute this drip.\n        require(\n            state.config.dripcheck.check(state.config.checkparams),\n            \"Drippie: dripcheck failed so drip is not yet ready to be triggered\"\n        );\n\n        // Alright, we're good to execute.\n        return true;\n    }\n\n    /**\n     * @notice Triggers a drip. This function is deliberately left as a public function because the\n     *         assumption being made here is that setting the drip to ACTIVE is an affirmative\n     *         signal that the drip should be executable according to the drip parameters, drip\n     *         check, and drip interval. Note that drip parameters are read entirely from the state\n     *         and are not supplied as user input, so there should not be any way for a\n     *         non-authorized user to influence the behavior of the drip. Note that the drip check\n     *         is executed only **once** at the beginning of the call to the drip function and will\n     *         not be executed again between the drip actions within this call.\n     *\n     * @param _name Name of the drip to trigger.\n     */\n    function drip(string calldata _name) external {\n        DripState storage state = drips[_name];\n\n        // Make sure the drip can be executed. Since executable reverts if the drip is not ready to\n        // be executed, we don't need to do an assertion that the returned value is true.\n        executable(_name);\n\n        // Update the last execution time for this drip before the call. Note that it's entirely\n        // possible for a drip to be executed multiple times per block or even multiple times\n        // within the same transaction (via re-entrancy) if the drip interval is set to zero. Users\n        // should set a drip interval of 1 if they'd like the drip to be executed only once per\n        // block (since this will then prevent re-entrancy).\n        state.last = block.timestamp;\n\n        // Update the number of times this drip has been executed. Although this increases the cost\n        // of using Drippie, it slightly simplifies the client-side by not having to worry about\n        // counting drips via events. Useful for monitoring the rate of drip execution.\n        state.count++;\n\n        // Execute each action in the drip. We allow drips to have multiple actions because there\n        // are scenarios in which a contract must do multiple things atomically. For example, the\n        // contract may need to withdraw ETH from one account and then deposit that ETH into\n        // another account within the same transaction.\n        uint256 len = state.config.actions.length;\n        for (uint256 i = 0; i < len; i++) {\n            // Must be marked as \"storage\" because copying structs into memory is not yet supported\n            // by Solidity. Won't significantly reduce gas costs but at least makes it easier to\n            // read what the rest of this section is doing.\n            DripAction storage action = state.config.actions[i];\n\n            // Actually execute the action. We could use ExcessivelySafeCall here but not strictly\n            // necessary (worst case, a drip gets bricked IFF the target is malicious, doubt this\n            // will ever happen in practice). Could save a marginal amount of gas to ignore the\n            // returndata.\n            // slither-disable-next-line calls-loop\n            (bool success, ) = action.target.call{ value: action.value }(action.data);\n\n            // Generally should not happen, but could if there's a misconfiguration (e.g., passing\n            // the wrong data to the target contract), the recipient is not payable, or\n            // insufficient gas was supplied to this transaction. We revert so the drip can be\n            // fixed and triggered again later. Means we cannot emit an event to alert of the\n            // failure, but can reasonably be detected by off-chain services even without an event.\n            // Note that this forces the drip executor to supply sufficient gas to the call\n            // (assuming there is some sufficient gas limit that exists, otherwise the drip will\n            // not execute).\n            require(\n                success,\n                \"Drippie: drip was unsuccessful, please check your configuration for mistakes\"\n            );\n        }\n\n        emit DripExecuted(_name, _name, msg.sender, block.timestamp);\n    }\n}\n"
+    },
+    "contracts/universal/drippie/IDripCheck.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IDripCheck {\n    // DripCheck contracts that want to take parameters as inputs MUST expose a struct called\n    // Params and an event _EventForExposingParamsStructInABI(Params params). This makes it\n    // possible to easily encode parameters on the client side. Solidity does not support generics\n    // so it's not possible to do this with explicit typing.\n\n    /**\n     * @notice Checks whether a drip should be executable.\n     *\n     * @param _params Encoded parameters for the drip check.\n     *\n     * @return Whether the drip should be executed.\n     */\n    function check(bytes memory _params) external view returns (bool);\n}\n"
+    },
+    "contracts/universal/drippie/dripchecks/CheckTrue.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IDripCheck } from \"../IDripCheck.sol\";\n\n/**\n * @title CheckTrue\n * @notice DripCheck that always returns true.\n */\ncontract CheckTrue is IDripCheck {\n    /**\n     * @inheritdoc IDripCheck\n     */\n    function check(bytes memory) external pure returns (bool) {\n        return true;\n    }\n}\n"
+    },
+    "contracts/universal/drippie/dripchecks/CheckGelatoLow.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IDripCheck } from \"../IDripCheck.sol\";\n\ninterface IGelatoTreasury {\n    function userTokenBalance(address _user, address _token) external view returns (uint256);\n}\n\n/**\n * @title CheckGelatoLow\n * @notice DripCheck for checking if an account's Gelato ETH balance is below some threshold.\n */\ncontract CheckGelatoLow is IDripCheck {\n    struct Params {\n        address treasury;\n        uint256 threshold;\n        address recipient;\n    }\n\n    /**\n     * @notice External event used to help client-side tooling encode parameters.\n     *\n     * @param params Parameters to encode.\n     */\n    event _EventToExposeStructInABI__Params(Params params);\n\n    /**\n     * @inheritdoc IDripCheck\n     */\n    function check(bytes memory _params) external view returns (bool) {\n        Params memory params = abi.decode(_params, (Params));\n\n        // Check GelatoTreasury ETH balance is below threshold.\n        return\n            IGelatoTreasury(params.treasury).userTokenBalance(\n                params.recipient,\n                // Gelato represents ETH as 0xeeeee....eeeee\n                0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE\n            ) < params.threshold;\n    }\n}\n"
+    },
+    "contracts/universal/drippie/dripchecks/CheckBalanceLow.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IDripCheck } from \"../IDripCheck.sol\";\n\n/**\n * @title CheckBalanceLow\n * @notice DripCheck for checking if an account's balance is below a given threshold.\n */\ncontract CheckBalanceLow is IDripCheck {\n    struct Params {\n        address target;\n        uint256 threshold;\n    }\n\n    /**\n     * @notice External event used to help client-side tooling encode parameters.\n     *\n     * @param params Parameters to encode.\n     */\n    event _EventToExposeStructInABI__Params(Params params);\n\n    /**\n     * @inheritdoc IDripCheck\n     */\n    function check(bytes memory _params) external view returns (bool) {\n        Params memory params = abi.decode(_params, (Params));\n\n        // Check target ETH balance is below threshold.\n        return params.target.balance < params.threshold;\n    }\n}\n"
+    },
+    "contracts/universal/drippie/dripchecks/CheckBalanceHigh.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IDripCheck } from \"../IDripCheck.sol\";\n\n/**\n * @title CheckBalanceHigh\n * @notice DripCheck for checking if an account's balance is above a given threshold.\n */\ncontract CheckBalanceHigh is IDripCheck {\n    struct Params {\n        address target;\n        uint256 threshold;\n    }\n\n    /**\n     * @notice External event used to help client-side tooling encode parameters.\n     *\n     * @param params Parameters to encode.\n     */\n    event _EventToExposeStructInABI__Params(Params params);\n\n    /**\n     * @inheritdoc IDripCheck\n     */\n    function check(bytes memory _params) external view returns (bool) {\n        Params memory params = abi.decode(_params, (Params));\n\n        // Check target balance is above threshold.\n        return params.target.balance > params.threshold;\n    }\n}\n"
+    },
+    "contracts/testing/helpers/TestERC721.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ERC721 } from \"@rari-capital/solmate/src/tokens/ERC721.sol\";\n\ncontract TestERC721 is ERC721 {\n    constructor() ERC721(\"TEST\", \"TST\") {}\n\n    function mint(address to, uint256 tokenId) public {\n        _mint(to, tokenId);\n    }\n\n    function tokenURI(uint256) public pure virtual override returns (string memory) {}\n}\n"
+    }
+  },
+  "settings": {
+    "optimizer": {
+      "enabled": true,
+      "runs": 10000
+    },
+    "outputSelection": {
+      "*": {
+        "*": [
+          "abi",
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "evm.methodIdentifiers",
+          "metadata",
+          "devdoc",
+          "userdoc",
+          "storageLayout",
+          "evm.gasEstimates"
+        ],
+        "": [
+          "ast"
+        ]
+      }
+    },
+    "metadata": {
+      "useLiteralContent": true
+    }
+  }
+}
\ No newline at end of file

packages/contracts-periphery/tasks/install-drippie-config.ts

 import { task } from 'hardhat/config'
 import { LedgerSigner } from '@ethersproject/hardware-wallets'
 import { PopulatedTransaction } from 'ethers'
+import '@nomiclabs/hardhat-ethers'
+import 'hardhat-deploy'
 
 import { isSameConfig, getDrippieConfig } from '../src'
 

specs/predeploys.md

@@ -46,11 +46,11 @@ indicates when the predeploy was introduced. The possible values are `Legacy`
 or `Bedrock`. Deprecated contracts should not be used.
 
 | Name                          | Address                                    | Introduced | Deprecated | Proxied |
-| ----------------------------- | ------------------------------------------ | ---------- | ---------- | ------- |
+| ----------------------------- | ------------------------------------------ | ---------- | ---------- |---------|
 | LegacyMessagePasser           | 0x4200000000000000000000000000000000000000 | Legacy     | Yes        | Yes     |
 | DeployerWhitelist             | 0x4200000000000000000000000000000000000002 | Legacy     | Yes        | Yes     |
 | LegacyERC20ETH                | 0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000 | Legacy     | Yes        | No      |
-| WETH9                         | 0x4200000000000000000000000000000000000006 | Legacy     | No         | Yes     |
+| WETH9                         | 0x4200000000000000000000000000000000000006 | Legacy     | No         | No      |
 | L2CrossDomainMessenger        | 0x4200000000000000000000000000000000000007 | Legacy     | No         | Yes     |
 | L2StandardBridge              | 0x4200000000000000000000000000000000000010 | Legacy     | No         | Yes     |
 | SequencerFeeVault             | 0x4200000000000000000000000000000000000011 | Legacy     | No         | Yes     |