Merge branch 'develop' into preset-block-heights

bedrock-devnet/devnet/__init__.py

@@ -56,8 +56,9 @@ def main():
     deployment_dir = pjoin(contracts_bedrock_dir, 'deployments', 'devnetL1')
     op_node_dir = pjoin(args.monorepo_dir, 'op-node')
     ops_bedrock_dir = pjoin(monorepo_dir, 'ops-bedrock')
-    deploy_config_dir = pjoin(contracts_bedrock_dir, 'deploy-config'),
-    devnet_config_path = pjoin(contracts_bedrock_dir, 'deploy-config', 'devnetL1.json')
+    deploy_config_dir = pjoin(contracts_bedrock_dir, 'deploy-config')
+    devnet_config_path = pjoin(deploy_config_dir, 'devnetL1.json')
+    devnet_config_template_path = pjoin(deploy_config_dir, 'devnetL1-template.json')
     ops_chain_ops = pjoin(monorepo_dir, 'op-chain-ops')
     sdk_dir = pjoin(monorepo_dir, 'packages', 'sdk')
 
@@ -69,6 +70,7 @@ def main():
       l1_deployments_path=pjoin(deployment_dir, '.deploy'),
       deploy_config_dir=deploy_config_dir,
       devnet_config_path=devnet_config_path,
+      devnet_config_template_path=devnet_config_template_path,
       op_node_dir=op_node_dir,
       ops_bedrock_dir=ops_bedrock_dir,
       ops_chain_ops=ops_chain_ops,
@@ -124,10 +126,16 @@ def deploy_contracts(paths):
         '--rpc-url', 'http://127.0.0.1:8545'
     ], env={}, cwd=paths.contracts_bedrock_dir)
 
-
+def init_devnet_l1_deploy_config(paths, update_timestamp=False):
+    deploy_config = read_json(paths.devnet_config_template_path)
+    if update_timestamp:
+        deploy_config['l1GenesisBlockTimestamp'] = '{:#x}'.format(int(time.time()))
+    write_json(paths.devnet_config_path, deploy_config)
 
 def devnet_l1_genesis(paths):
     log.info('Generating L1 genesis state')
+    init_devnet_l1_deploy_config(paths)
+
     geth = subprocess.Popen([
         'geth', '--dev', '--http', '--http.api', 'eth,debug',
         '--verbosity', '4', '--gcmode', 'archive', '--dev.gaslimit', '30000000'
@@ -157,13 +165,13 @@ def devnet_deploy(paths):
         if os.path.exists(paths.allocs_path) == False:
             devnet_l1_genesis(paths)
 
-        devnet_config_backup = pjoin(paths.devnet_dir, 'devnetL1.json.bak')
-        shutil.copy(paths.devnet_config_path, devnet_config_backup)
-        deploy_config = read_json(paths.devnet_config_path)
-        deploy_config['l1GenesisBlockTimestamp'] = '{:#x}'.format(int(time.time()))
-        write_json(paths.devnet_config_path, deploy_config)
+        # It's odd that we want to regenerate the devnetL1.json file with
+        # an updated timestamp different than the one used in the devnet_l1_genesis
+        # function.  But, without it, CI flakes on this test rather consistently.
+        # If someone reads this comment and understands why this is being done, please
+        # update this comment to explain.
+        init_devnet_l1_deploy_config(paths, update_timestamp=True)
         outfile_l1 = pjoin(paths.devnet_dir, 'genesis-l1.json')
-
         run_command([
             'go', 'run', 'cmd/main.go', 'genesis', 'l1',
             '--deploy-config', paths.devnet_config_path,

docs/fault-proof-alpha/README.md

@@ -14,3 +14,4 @@ finalized and may change without notice.
  * [Manual Usage](./manual.md)
    * [Creating Traces with Cannon](./cannon.md)
  * [Automation with `op-challenger`](./run-challenger.md)
+ * [Challenging Invalid Output Proposals](./invalid-proposals.md)

docs/fault-proof-alpha/invalid-proposals.md

+## Challenging Invalid Output Proposals
+
+The dispute game factory deployed to Goerli reads from the permissioned L2 Output Oracle contract. This restricts games
+to challenging valid output proposals and an honest challenger should win every game. To test creating games that
+challenge an invalid output proposal, a custom chain is required. The simplest way to do this is using the end-to-end
+test utilities in [`op-e2e`](https://github.com/ethereum-optimism/optimism/tree/develop/op-e2e).
+
+A simple starting point has been provided in the `TestCannonProposedOutputRootInvalid` test case
+in [`faultproof_test.go`](https://github.com/ethereum-optimism/optimism/blob/6e174ae2b2587d9ac5e2930d7574f85d254ca8b4/op-e2e/faultproof_test.go#L334).
+This is a table test that takes the output root to propose, plus functions for move and step to counter the honest
+claims. The test asserts that the defender always wins and thus the output root is found to be invalid.

op-e2e/faultproof_test.go

@@ -13,43 +13,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestMultipleAlphabetGames(t *testing.T) {
-	InitParallel(t)
-
-	ctx := context.Background()
-	sys, l1Client := startFaultDisputeSystem(t)
-	t.Cleanup(sys.Close)
-
-	gameFactory := disputegame.NewFactoryHelper(t, ctx, sys.cfg.L1Deployments, l1Client)
-	// Start a challenger with the correct alphabet trace
-	gameFactory.StartChallenger(ctx, sys.NodeEndpoint("l1"), "TowerDefense",
-		challenger.WithAlphabet("abcdefg"),
-		challenger.WithPrivKey(sys.cfg.Secrets.Alice),
-		challenger.WithAgreeProposedOutput(true),
-	)
-
-	game1 := gameFactory.StartAlphabetGame(ctx, "abcxyz")
-	// Wait for the challenger to respond to the first game
-	game1.WaitForClaimCount(ctx, 2)
-
-	game2 := gameFactory.StartAlphabetGame(ctx, "zyxabc")
-	// Wait for the challenger to respond to the second game
-	game2.WaitForClaimCount(ctx, 2)
-
-	// Challenger should respond to new claims
-	game2.Attack(ctx, 1, common.Hash{0xaa})
-	game2.WaitForClaimCount(ctx, 4)
-	game1.Defend(ctx, 1, common.Hash{0xaa})
-	game1.WaitForClaimCount(ctx, 4)
-
-	gameDuration := game1.GameDuration(ctx)
-	sys.TimeTravelClock.AdvanceTime(gameDuration)
-	require.NoError(t, wait.ForNextBlock(ctx, l1Client))
-
-	game1.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
-	game2.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
-}
-
 func TestMultipleCannonGames(t *testing.T) {
 	InitParallel(t)
 
@@ -106,36 +69,6 @@ func TestMultipleCannonGames(t *testing.T) {
 	challenger.WaitForGameDataDeletion(ctx, game1, game2)
 }
 
-func TestResolveDisputeGame(t *testing.T) {
-	InitParallel(t)
-
-	ctx := context.Background()
-	sys, l1Client := startFaultDisputeSystem(t)
-	t.Cleanup(sys.Close)
-
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.cfg.L1Deployments, l1Client)
-
-	game := disputeGameFactory.StartAlphabetGame(ctx, "zyxwvut")
-	require.NotNil(t, game)
-	gameDuration := game.GameDuration(ctx)
-
-	game.WaitForGameStatus(ctx, disputegame.StatusInProgress)
-
-	game.StartChallenger(ctx, sys.NodeEndpoint("l1"), "HonestAlice",
-		challenger.WithAgreeProposedOutput(true),
-		challenger.WithAlphabet("abcdefg"),
-		challenger.WithPrivKey(sys.cfg.Secrets.Alice),
-	)
-
-	game.WaitForClaimCount(ctx, 2)
-
-	sys.TimeTravelClock.AdvanceTime(gameDuration)
-	require.NoError(t, wait.ForNextBlock(ctx, l1Client))
-
-	// Challenger should resolve the game now that the clocks have expired.
-	game.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
-}
-
 func TestChallengerCompleteDisputeGame(t *testing.T) {
 	InitParallel(t)
 
@@ -333,22 +266,32 @@ func TestCannonDefendStep(t *testing.T) {
 
 func TestCannonProposedOutputRootInvalid(t *testing.T) {
 	InitParallel(t)
-	honestStepsFail := func(ctx context.Context, correctTrace *disputegame.HonestHelper, parentClaimIdx int64) {
+	// honestStepsFail attempts to perform both an attack and defend step using the correct trace.
+	honestStepsFail := func(ctx context.Context, game *disputegame.CannonGameHelper, correctTrace *disputegame.HonestHelper, parentClaimIdx int64) {
 		// Attack step should fail
 		correctTrace.StepFails(ctx, parentClaimIdx, true)
 		// Defending should fail too
 		correctTrace.StepFails(ctx, parentClaimIdx, false)
 	}
 	tests := []struct {
-		name        string
-		outputRoot  common.Hash
-		performMove func(ctx context.Context, correctTrace *disputegame.HonestHelper, parentClaimIdx int64)
-		performStep func(ctx context.Context, correctTrace *disputegame.HonestHelper, parentClaimIdx int64)
+		// name is the name of the test
+		name string
+
+		// outputRoot is the invalid output root to propose
+		outputRoot common.Hash
+
+		// performMove is called to respond to each claim posted by the honest op-challenger.
+		// It should either attack or defend the claim at parentClaimIdx
+		performMove func(ctx context.Context, game *disputegame.CannonGameHelper, correctTrace *disputegame.HonestHelper, parentClaimIdx int64)
+
+		// performStep is called once the maximum game depth is reached. It should perform a step to counter the
+		// claim at parentClaimIdx. Since the proposed output root is invalid, the step call should always revert.
+		performStep func(ctx context.Context, game *disputegame.CannonGameHelper, correctTrace *disputegame.HonestHelper, parentClaimIdx int64)
 	}{
 		{
 			name:       "AttackWithCorrectTrace",
 			outputRoot: common.Hash{0xab},
-			performMove: func(ctx context.Context, correctTrace *disputegame.HonestHelper, parentClaimIdx int64) {
+			performMove: func(ctx context.Context, game *disputegame.CannonGameHelper, correctTrace *disputegame.HonestHelper, parentClaimIdx int64) {
 				// Attack everything but oddly using the correct hash.
 				correctTrace.Attack(ctx, parentClaimIdx)
 			},
@@ -357,7 +300,7 @@ func TestCannonProposedOutputRootInvalid(t *testing.T) {
 		{
 			name:       "DefendWithCorrectTrace",
 			outputRoot: common.Hash{0xab},
-			performMove: func(ctx context.Context, correctTrace *disputegame.HonestHelper, parentClaimIdx int64) {
+			performMove: func(ctx context.Context, game *disputegame.CannonGameHelper, correctTrace *disputegame.HonestHelper, parentClaimIdx int64) {
 				// Can only attack the root claim
 				if parentClaimIdx == 0 {
 					correctTrace.Attack(ctx, parentClaimIdx)
@@ -376,16 +319,16 @@ func TestCannonProposedOutputRootInvalid(t *testing.T) {
 			InitParallel(t)
 
 			ctx := context.Background()
-			sys, l1Client, game, correctTrace := setupDisputeGameForInvalidOutputRoot(t, common.Hash{0xab})
+			sys, l1Client, game, correctTrace := setupDisputeGameForInvalidOutputRoot(t, test.outputRoot)
 			t.Cleanup(sys.Close)
 
 			// Now maliciously play the game and it should be impossible to win
 			game.ChallengeRootClaim(ctx,
 				func(parentClaimIdx int64) {
-					test.performMove(ctx, correctTrace, parentClaimIdx)
+					test.performMove(ctx, game, correctTrace, parentClaimIdx)
 				},
 				func(parentClaimIdx int64) {
-					test.performStep(ctx, correctTrace, parentClaimIdx)
+					test.performStep(ctx, game, correctTrace, parentClaimIdx)
 				})
 
 			// Time travel past when the game will be resolvable.

op-ufm/Dockerfile

@@ -18,9 +18,10 @@ COPY --from=builder /app/entrypoint.sh /bin/entrypoint.sh
 COPY --from=builder /app/bin/ufm /bin/ufm
 
 RUN apk update && \
-    apk add ca-certificates && \
     chmod +x /bin/entrypoint.sh
 
+RUN apk add ca-certificates jq curl bind-tools
+
 VOLUME /etc/ufm
 
 EXPOSE 8080

op-ufm/example.config.toml

@@ -39,12 +39,6 @@ address = "0x0000000000000000000000000000000000000000"
 private_key = "0000000000000000000000000000000000000000000000000000000000000000"
 # Transaction value in wei
 tx_value = 100000000000000
-# Gas limit
-gas_limit = 21000
-# Gas tip cap
-gas_tip_cap = 2000000000
-# Fee cap
-gas_fee_cap = 20000000000
 
 [providers.p1]
 # URL to the RPC provider
@@ -52,13 +46,15 @@ url = "http://localhost:8551"
 # Read only providers are only used to check for transactions
 read_only = true
 # Interval to poll the provider for expected transactions
-read_interval = "1s"
+read_interval = "10s"
 # Interval to submit new transactions to the provider
-send_interval = "5s"
-# Wallet to be used for sending transactions
-wallet = "default"
-# Network to pool transactions, i.e. providers in the same network will check transactions from each other
-network = "op-goerli"
+send_interval = "30s"
+# Interval between send transaction when we get "already known" txpool err
+send_transaction_retry_interval = "100ms"
+# Max time to retry
+send_transaction_retry_timeout = "5s"
+# Interval between each send transaction to the same network
+send_transaction_cool_down = "30s"
 # Interval between receipt retrieval
 receipt_retrieval_interval = "500ms"
 # Max time to check for receipt
@@ -72,13 +68,15 @@ url = "http://localhost:8552"
 # Read only providers are only used to check for transactions
 read_only = false
 # Interval to poll the provider for expected transactions
-read_interval = "2s"
+read_interval = "10s"
 # Interval to submit new transactions to the provider
-send_interval = "3s"
-# Wallet to be used for sending transactions
-wallet = "default"
-# Network to pool transactions, i.e. providers in the same network will check transactions from each other
-network = "op-goerli"
+send_interval = "30s"
+# Interval between send transaction when we get "already known" txpool err
+send_transaction_retry_interval = "100ms"
+# Max time to retry
+send_transaction_retry_timeout = "5s"
+# Interval between each send transaction to the same network
+send_transaction_cool_down = "30s"
 # Interval between receipt retrieval
 receipt_retrieval_interval = "500ms"
 # Max time to check for receipt

op-ufm/pkg/config/config.go

@@ -48,10 +48,7 @@ type WalletConfig struct {
 	PrivateKey string `toml:"private_key"`
 
 	// transaction parameters
-	TxValue   big.Int `toml:"tx_value"`
-	GasLimit  uint64  `toml:"gas_limit"`
-	GasTipCap big.Int `toml:"gas_tip_cap"`
-	GasFeeCap big.Int `toml:"gas_fee_cap"`
+	TxValue big.Int `toml:"tx_value"`
 }
 
 type ProviderConfig struct {
@@ -64,6 +61,7 @@ type ProviderConfig struct {
 	SendInterval                 TOMLDuration `toml:"send_interval"`
 	SendTransactionRetryInterval TOMLDuration `toml:"send_transaction_retry_interval"`
 	SendTransactionRetryTimeout  TOMLDuration `toml:"send_transaction_retry_timeout"`
+	SendTransactionCoolDown      TOMLDuration `toml:"send_transaction_cool_down"`
 	ReceiptRetrievalInterval     TOMLDuration `toml:"receipt_retrieval_interval"`
 	ReceiptRetrievalTimeout      TOMLDuration `toml:"receipt_retrieval_timeout"`
 
@@ -130,12 +128,6 @@ func (c *Config) Validate() error {
 		if wallet.TxValue.BitLen() == 0 {
 			return errors.Errorf("wallet [%s] tx_value is missing", name)
 		}
-		if wallet.GasLimit == 0 {
-			return errors.Errorf("wallet [%s] gas_limit is missing", name)
-		}
-		if wallet.GasFeeCap.BitLen() == 0 {
-			return errors.Errorf("wallet [%s] gas_fee_cap is missing", name)
-		}
 	}
 
 	for name, provider := range c.Providers {
@@ -154,6 +146,9 @@ func (c *Config) Validate() error {
 		if provider.SendTransactionRetryTimeout == 0 {
 			return errors.Errorf("provider [%s] send_transaction_retry_timeout is missing", name)
 		}
+		if provider.SendTransactionCoolDown == 0 {
+			return errors.Errorf("provider [%s] send_transaction_cool_down is missing", name)
+		}
 		if provider.ReceiptRetrievalInterval == 0 {
 			return errors.Errorf("provider [%s] receipt_retrieval_interval is missing", name)
 		}

op-ufm/pkg/metrics/clients/eth.go

@@ -2,6 +2,7 @@ package clients
 
 import (
 	"context"
+	"math/big"
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-ufm/pkg/metrics"
@@ -22,7 +23,7 @@ func Dial(providerName string, url string) (*InstrumentedEthClient, error) {
 	start := time.Now()
 	c, err := ethclient.Dial(url)
 	if err != nil {
-		metrics.RecordError(providerName, "ethclient.Dial")
+		metrics.RecordErrorDetails(providerName, "ethclient.Dial", err)
 		return nil, err
 	}
 	metrics.RecordRPCLatency(providerName, "ethclient", "Dial", time.Since(start))
@@ -34,7 +35,7 @@ func (i *InstrumentedEthClient) TransactionByHash(ctx context.Context, hash comm
 	tx, isPending, err := i.c.TransactionByHash(ctx, hash)
 	if err != nil {
 		if !i.ignorableErrors(err) {
-			metrics.RecordError(i.providerName, "ethclient.TransactionByHash")
+			metrics.RecordErrorDetails(i.providerName, "ethclient.TransactionByHash", err)
 		}
 		return nil, false, err
 	}
@@ -46,7 +47,7 @@ func (i *InstrumentedEthClient) PendingNonceAt(ctx context.Context, address stri
 	start := time.Now()
 	nonce, err := i.c.PendingNonceAt(ctx, common.HexToAddress(address))
 	if err != nil {
-		metrics.RecordError(i.providerName, "ethclient.PendingNonceAt")
+		metrics.RecordErrorDetails(i.providerName, "ethclient.PendingNonceAt", err)
 		return 0, err
 	}
 	metrics.RecordRPCLatency(i.providerName, "ethclient", "PendingNonceAt", time.Since(start))
@@ -58,7 +59,7 @@ func (i *InstrumentedEthClient) TransactionReceipt(ctx context.Context, txHash c
 	receipt, err := i.c.TransactionReceipt(ctx, txHash)
 	if err != nil {
 		if !i.ignorableErrors(err) {
-			metrics.RecordError(i.providerName, "ethclient.TransactionReceipt")
+			metrics.RecordErrorDetails(i.providerName, "ethclient.TransactionReceipt", err)
 		}
 		return nil, err
 	}
@@ -71,7 +72,7 @@ func (i *InstrumentedEthClient) SendTransaction(ctx context.Context, tx *types.T
 	err := i.c.SendTransaction(ctx, tx)
 	if err != nil {
 		if !i.ignorableErrors(err) {
-			metrics.RecordError(i.providerName, "ethclient.SendTransaction")
+			metrics.RecordErrorDetails(i.providerName, "ethclient.SendTransaction", err)
 		}
 		return err
 	}
@@ -79,6 +80,39 @@ func (i *InstrumentedEthClient) SendTransaction(ctx context.Context, tx *types.T
 	return err
 }
 
+func (i *InstrumentedEthClient) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64, error) {
+	start := time.Now()
+	gas, err := i.c.EstimateGas(ctx, msg)
+	if err != nil {
+		metrics.RecordErrorDetails(i.providerName, "ethclient.EstimateGas", err)
+		return 0, err
+	}
+	metrics.RecordRPCLatency(i.providerName, "ethclient", "EstimateGas", time.Since(start))
+	return gas, err
+}
+
+func (i *InstrumentedEthClient) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
+	start := time.Now()
+	gasTipCap, err := i.c.SuggestGasTipCap(ctx)
+	if err != nil {
+		metrics.RecordErrorDetails(i.providerName, "ethclient.SuggestGasTipCap", err)
+		return nil, err
+	}
+	metrics.RecordRPCLatency(i.providerName, "ethclient", "SuggestGasTipCap", time.Since(start))
+	return gasTipCap, err
+}
+
+func (i *InstrumentedEthClient) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
+	start := time.Now()
+	header, err := i.c.HeaderByNumber(ctx, number)
+	if err != nil {
+		metrics.RecordErrorDetails(i.providerName, "ethclient.HeaderByNumber", err)
+		return nil, err
+	}
+	metrics.RecordRPCLatency(i.providerName, "ethclient", "HeaderByNumber", time.Since(start))
+	return header, err
+}
+
 func (i *InstrumentedEthClient) ignorableErrors(err error) bool {
 	msg := err.Error()
 	// we dont use errors.Is because eth client actually uses errors.New,

op-ufm/pkg/metrics/clients/signer.go

@@ -22,7 +22,7 @@ func NewSignerClient(providerName string, logger log.Logger, endpoint string, tl
 	start := time.Now()
 	c, err := signer.NewSignerClient(logger, endpoint, tlsConfig)
 	if err != nil {
-		metrics.RecordError(providerName, "signer.NewSignerClient")
+		metrics.RecordErrorDetails(providerName, "signer.NewSignerClient", err)
 		return nil, err
 	}
 	metrics.RecordRPCLatency(providerName, "signer", "NewSignerClient", time.Since(start))
@@ -33,7 +33,7 @@ func (i *InstrumentedSignerClient) SignTransaction(ctx context.Context, chainId
 	start := time.Now()
 	tx, err := i.c.SignTransaction(ctx, chainId, tx)
 	if err != nil {
-		metrics.RecordError(i.providerName, "signer.SignTransaction")
+		metrics.RecordErrorDetails(i.providerName, "signer.SignTransaction", err)
 		return nil, err
 	}
 	metrics.RecordRPCLatency(i.providerName, "signer", "SignTransaction", time.Since(start))

op-ufm/pkg/provider/roundtrip.go

@@ -2,6 +2,7 @@ package provider
 
 import (
 	"context"
+	"math/big"
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-ufm/pkg/metrics"
@@ -21,7 +22,7 @@ import (
 
 // RoundTrip send a new transaction to measure round trip latency
 func (p *Provider) RoundTrip(ctx context.Context) {
-	log.Debug("roundTripLatency",
+	log.Debug("RoundTrip",
 		"provider", p.name)
 
 	client, err := iclients.Dial(p.name, p.config.URL)
@@ -33,33 +34,38 @@ func (p *Provider) RoundTrip(ctx context.Context) {
 		return
 	}
 
-	var nonce uint64
-	p.txPool.M.Lock()
-	if p.txPool.Nonce == uint64(0) {
-		nonce, err = client.PendingNonceAt(ctx, p.walletConfig.Address)
-		if err != nil {
-			log.Error("cant get nounce",
-				"provider", p.name,
-				"err", err)
-			p.txPool.M.Unlock()
-			return
-		}
-		p.txPool.Nonce = nonce
-	} else {
-		p.txPool.Nonce++
-		nonce = p.txPool.Nonce
-	}
-	p.txPool.M.Unlock()
+	p.txPool.ExclusiveSend.Lock()
+	defer p.txPool.ExclusiveSend.Unlock()
 
 	txHash := common.Hash{}
 	attempt := 0
+	nonce := uint64(0)
+
 	// used for timeout
 	firstAttemptAt := time.Now()
 	// used for actual round trip time (disregard retry time)
-	roundTripStartedAt := time.Now()
+	var roundTripStartedAt time.Time
 	for {
-		tx := p.createTx(nonce)
-		txHash = tx.Hash()
+
+		// sleep until we get a clear to send
+		for {
+			coolDown := time.Duration(p.config.SendTransactionCoolDown) - time.Since(p.txPool.LastSend)
+			if coolDown > 0 {
+				time.Sleep(coolDown)
+			} else {
+				break
+			}
+		}
+
+		tx, err := p.createTx(ctx, client, nonce)
+		nonce = tx.Nonce()
+		if err != nil {
+			log.Error("cant create tx",
+				"provider", p.name,
+				"nonce", nonce,
+				"err", err)
+			return
+		}
 
 		signedTx, err := p.sign(ctx, tx)
 		if err != nil {
@@ -69,7 +75,6 @@ func (p *Provider) RoundTrip(ctx context.Context) {
 				"err", err)
 			return
 		}
-
 		txHash = signedTx.Hash()
 
 		roundTripStartedAt = time.Now()
@@ -78,25 +83,29 @@ func (p *Provider) RoundTrip(ctx context.Context) {
 			if err.Error() == txpool.ErrAlreadyKnown.Error() ||
 				err.Error() == txpool.ErrReplaceUnderpriced.Error() ||
 				err.Error() == core.ErrNonceTooLow.Error() {
+
+				log.Warn("cant send transaction (retryable)",
+					"provider", p.name,
+					"err", err,
+					"nonce", nonce)
+
 				if time.Since(firstAttemptAt) >= time.Duration(p.config.SendTransactionRetryTimeout) {
 					log.Error("send transaction timed out (known already)",
 						"provider", p.name,
 						"hash", txHash.Hex(),
+						"nonce", nonce,
 						"elapsed", time.Since(firstAttemptAt),
-						"attempt", attempt,
-						"nonce", nonce)
-					metrics.RecordError(p.name, "ethclient.SendTransaction.nonce")
+						"attempt", attempt)
+					metrics.RecordErrorDetails(p.name, "send.timeout", err)
 					return
 				}
+
 				log.Warn("tx already known, incrementing nonce and trying again",
 					"provider", p.name,
 					"nonce", nonce)
 				time.Sleep(time.Duration(p.config.SendTransactionRetryInterval))
 
-				p.txPool.M.Lock()
-				p.txPool.Nonce++
-				nonce = p.txPool.Nonce
-				p.txPool.M.Unlock()
+				nonce++
 				attempt++
 				if attempt%10 == 0 {
 					log.Debug("retrying send transaction...",
@@ -108,6 +117,7 @@ func (p *Provider) RoundTrip(ctx context.Context) {
 			} else {
 				log.Error("cant send transaction",
 					"provider", p.name,
+					"nonce", nonce,
 					"err", err)
 				metrics.RecordErrorDetails(p.name, "ethclient.SendTransaction", err)
 				return
@@ -131,6 +141,7 @@ func (p *Provider) RoundTrip(ctx context.Context) {
 		SentAt:         sentAt,
 		SeenBy:         make(map[string]time.Time),
 	}
+	p.txPool.LastSend = sentAt
 	p.txPool.M.Unlock()
 
 	var receipt *types.Receipt
@@ -140,13 +151,17 @@ func (p *Provider) RoundTrip(ctx context.Context) {
 			log.Error("receipt retrieval timed out",
 				"provider", p.name,
 				"hash", txHash,
+				"nonce", nonce,
 				"elapsed", time.Since(sentAt))
+			metrics.RecordErrorDetails(p.name, "receipt.timeout", err)
 			return
 		}
 		time.Sleep(time.Duration(p.config.ReceiptRetrievalInterval))
 		if attempt%10 == 0 {
 			log.Debug("checking for receipt...",
 				"provider", p.name,
+				"hash", txHash,
+				"nonce", nonce,
 				"attempt", attempt,
 				"elapsed", time.Since(sentAt))
 		}
@@ -155,6 +170,7 @@ func (p *Provider) RoundTrip(ctx context.Context) {
 			log.Error("cant get receipt for transaction",
 				"provider", p.name,
 				"hash", txHash.Hex(),
+				"nonce", nonce,
 				"err", err)
 			return
 		}
@@ -168,6 +184,7 @@ func (p *Provider) RoundTrip(ctx context.Context) {
 
 	log.Info("got transaction receipt",
 		"hash", txHash.Hex(),
+		"nonce", nonce,
 		"roundTripLatency", roundTripLatency,
 		"provider", p.name,
 		"blockNumber", receipt.BlockNumber,
@@ -175,20 +192,83 @@ func (p *Provider) RoundTrip(ctx context.Context) {
 		"gasUsed", receipt.GasUsed)
 }
 
-func (p *Provider) createTx(nonce uint64) *types.Transaction {
-	toAddress := common.HexToAddress(p.walletConfig.Address)
+func (p *Provider) createTx(ctx context.Context, client *iclients.InstrumentedEthClient, nonce uint64) (*types.Transaction, error) {
+	var err error
+	if nonce == 0 {
+		nonce, err = client.PendingNonceAt(ctx, p.walletConfig.Address)
+		if err != nil {
+			log.Error("cant get nounce",
+				"provider", p.name,
+				"nonce", nonce,
+				"err", err)
+			return nil, err
+		}
+	}
+
+	gasTipCap, err := client.SuggestGasTipCap(ctx)
+	if err != nil {
+		log.Error("cant get gas tip cap",
+			"provider", p.name,
+			"err", err)
+		return nil, err
+	}
+	gasTipCap = new(big.Int).Mul(gasTipCap, big.NewInt(110))
+	gasTipCap = new(big.Int).Div(gasTipCap, big.NewInt(100))
+
+	head, err := client.HeaderByNumber(ctx, nil)
+	if err != nil {
+		log.Error("cant get base fee from head",
+			"provider", p.name,
+			"err", err)
+		return nil, err
+	}
+	baseFee := head.BaseFee
+
+	gasFeeCap := new(big.Int).Add(
+		gasTipCap,
+		new(big.Int).Mul(baseFee, big.NewInt(2)))
+
+	addr := common.HexToAddress(p.walletConfig.Address)
 	var data []byte
-	tx := types.NewTx(&types.DynamicFeeTx{
+	dynamicTx := &types.DynamicFeeTx{
 		ChainID:   &p.walletConfig.ChainID,
 		Nonce:     nonce,
-		GasFeeCap: &p.walletConfig.GasFeeCap,
-		GasTipCap: &p.walletConfig.GasTipCap,
-		Gas:       p.walletConfig.GasLimit,
-		To:        &toAddress,
+		GasFeeCap: gasFeeCap,
+		GasTipCap: gasTipCap,
+		To:        &addr,
 		Value:     &p.walletConfig.TxValue,
 		Data:      data,
+	}
+
+	gas, err := client.EstimateGas(ctx, ethereum.CallMsg{
+		From:      addr,
+		To:        &addr,
+		GasFeeCap: gasFeeCap,
+		GasTipCap: gasTipCap,
+		Data:      dynamicTx.Data,
+		Value:     dynamicTx.Value,
 	})
-	return tx
+	if err != nil {
+		log.Error("cant estimate gas",
+			"provider", p.name,
+			"err", err)
+		return nil, err
+	}
+	dynamicTx.Gas = gas
+	tx := types.NewTx(dynamicTx)
+
+	log.Info("tx created",
+		"provider", p.name,
+		"from", addr,
+		"to", dynamicTx.To,
+		"nonce", dynamicTx.Nonce,
+		"value", dynamicTx.Value,
+		"gas", dynamicTx.Gas,
+		"gasTipCap", dynamicTx.GasTipCap,
+		"gasFeeCap", dynamicTx.GasFeeCap,
+	)
+
+	return tx, nil
 }
 
 func (p *Provider) sign(ctx context.Context, tx *types.Transaction) (*types.Transaction, error) {

op-ufm/pkg/provider/tx_pool.go

@@ -15,7 +15,11 @@ type NetworkTransactionPool struct {
 	M            sync.Mutex
 	Transactions map[string]*TransactionState
 	Expected     int
-	Nonce        uint64
+
+	// Last time a transaction was sent
+	LastSend time.Time
+	// Prevents concurrent transaction send
+	ExclusiveSend sync.Mutex
 }
 
 type TransactionState struct {

package.json

@@ -66,7 +66,7 @@
     "lint-staged": "14.0.1",
     "markdownlint": "^0.30.0",
     "markdownlint-cli2": "0.4.0",
-    "mkdirp": "^1.0.4",
+    "mkdirp": "^3.0.1",
     "mocha": "^10.2.0",
     "nx": "16.7.3",
     "nyc": "^15.1.0",

packages/contracts-bedrock/.gitignore

@@ -26,3 +26,6 @@ deployments/hardhat
 deployments/getting-started
 deployments/*/.deploy
 deployments/1337
+
+# Devnet config which changes with each 'make devnet-up'
+deploy-config/devnetL1.json

packages/contracts-bedrock/STYLE_GUIDE.md

@@ -138,6 +138,9 @@ Test contracts should be named one of the following according to their use:
 - `TargetContract_Function_Test` for contracts containing happy path tests for a given function.
 - `TargetContract_Function_TestFail` for contracts containing sad path tests for a given function.
 
+To minimize clutter, getter functions can be grouped together into a single test contract,
+  ie. `TargetContract_Getters_Test`.
+
 ## Withdrawaing From Fee Vaults
 
 See the file `scripts/FeeVaultWithdrawal.s.sol` to withdraw from the L2 fee vaults. It includes

pnpm-workspace.yaml

@@ -2,3 +2,4 @@ packages:
   - 'packages/*'
   - 'endpoint-monitor'
   - 'op-exporter'
+  - 'ufm-test-services/metamask'

ufm-test-services/crontab-example

+# Needs to point to docker, otherwise you'll get the error: exec: "docker": executable file not found in $PATH
+PATH=/
+
+# Runs every minute
+* * * * * /usr/local/bin/docker-compose -f /path/to/docker-compose.yml --profile 1minute up -d
+
+# Runs every 5 minutes
+*/5 * * * * /usr/local/bin/docker-compose -f /path/to/docker-compose.yml --profile 5minutes up -d
\ No newline at end of file

ufm-test-services/datesources.yml

+apiVersion: 1
+
+datasources:
+  - name: Prometheus
+    type: prometheus
+    access: proxy
+    url: http://prometheus:9090
+    isDefault: true
\ No newline at end of file

ufm-test-services/docker-compose.yml

+version: "3"
+
+services:
+  pushgateway:
+    image: prom/pushgateway
+    ports:
+      - "9091:9091"
+    restart: unless-stopped
+    read_only: true
+    security_opt:
+      - "no-new-privileges:true"
+
+  prometheus:
+    image: prom/prometheus:latest
+    container_name: prometheus
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./prometheus.yml:/etc/prometheus/prometheus.yml
+    depends_on:
+      - pushgateway
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+    read_only: true
+    security_opt:
+      - "no-new-privileges:true"
+
+  grafana:
+    image: grafana/grafana:latest
+    container_name: grafana
+    ports:
+      - "3000:3000"
+    depends_on:
+      - prometheus
+    environment:
+      # TODO - Replace with ENV variables to allow for better security
+      - GF_SECURITY_ADMIN_PASSWORD=adminpassword
+    volumes:
+      - ./datesources.yml:/etc/grafana/provisioning/datasources/datasources.yaml
+    security_opt:
+      - "no-new-privileges:true"
+
+  # Example Test Service Config
+  # my_test_service:
+  #   build: ./my_test_service_dir
+  #   container_name: my_test_service
+  #   profiles: ["1minute"]
+  #   depends_on:
+  #     - prometheus
+  #   restart: no

ufm-test-services/metamask/Dockerfile

+FROM node:18
+
+WORKDIR /app
+
+COPY ./ ./
+
+RUN npm i -g pnpm
+RUN pnpm install
+
+CMD /bin/sh /app/start.sh

ufm-test-services/metamask/LICENSE

+MIT License
+
+Copyright (c) 2023 Optimism
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ufm-test-services/metamask/package.json

+{
+  "name": "@eth-optimism/ufm-test-service-metamask",
+  "version": "0.1.0",
+  "description": "A User facing monitoring Test Service for MetaMask",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ethereum-optimism/optimism.git",
+    "directory": "ufm-test-services/metamask"
+  },
+  "homepage": "https://optimism.io",
+  "type": "module",
+  "scripts": {
+    "lint": "prettier --check .",
+    "lint:fix": "prettier --write ."
+  },
+  "devDependencies": {
+    "typescript": "^5.1.6"
+  }
+}

ufm-test-services/metamask/start.sh

+#!/bin/bash
\ No newline at end of file

ufm-test-services/metamask/tsconfig.json

+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "baseUrl": "./src",
+    "noEmit": true,
+    "target": "ESNext",
+    "lib": ["esnext"],
+    "module": "esnext",
+    "moduleResolution": "Node",
+    "isolatedModules": true,
+    "allowUnreachableCode": false,
+    "skipLibCheck": false,
+    "allowUnusedLabels": false,
+    "alwaysStrict": true,
+    "exactOptionalPropertyTypes": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noImplicitOverride": true,
+    "noImplicitThis": true,
+    "forceConsistentCasingInFileNames": true,
+    "verbatimModuleSyntax": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "strict": true
+  },
+  "include": ["./src"]
+}

ufm-test-services/prometheus.yml

+global:
+  scrape_interval: 5s
+
+scrape_configs:
+  - job_name: 'pushgateway'
+    static_configs:
+      - targets: ['pushgateway:9091']
\ No newline at end of file