Merge branch 'develop' into p2p-ban-utils

.circleci/config.yml

@@ -248,6 +248,10 @@ jobs:
       docker_context:
         description: Docker build context
         type: string
+      docker_target:
+        description: "target build stage"
+        type: string
+        default: ""
       registry:
         description: Docker registry
         type: string
@@ -278,7 +282,7 @@ jobs:
             DOCKER_TAGS=$(echo -ne <<parameters.docker_tags>> | sed "s/,/\n/g" | sed "s/[^a-zA-Z0-9\n]/-/g" | sed -e "s|^|-t ${IMAGE_BASE}:|")
             docker context create buildx-build
             docker buildx create --use buildx-build
-            docker buildx build --platform=<<parameters.platforms>> --push \
+            docker buildx build --platform=<<parameters.platforms>> --target "<<parameters.docker_target>>" --push \
               $(echo -ne $DOCKER_TAGS | tr '\n' ' ') \
               -f <<parameters.docker_file>> \
               <<parameters.docker_context>>
@@ -639,6 +643,18 @@ jobs:
           command: make fuzz
           working_directory: op-node
 
+  fuzz-op-chain-ops:
+    docker:
+      - image: us-docker.pkg.dev/oplabs-tools-artifacts/images/ci-builder:latest
+    steps:
+      - checkout
+      - check-changed:
+          patterns: op-chain-ops,op-bindings
+      - run:
+          name: Fuzz
+          command: make fuzz
+          working_directory: op-chain-ops
+
   depcheck:
     docker:
       - image: us-docker.pkg.dev/oplabs-tools-artifacts/images/ci-builder:latest
@@ -1282,6 +1298,7 @@ workflows:
       - semgrep-scan
       - go-mod-tidy
       - fuzz-op-node
+      - fuzz-op-chain-ops
       - bedrock-markdown
       - go-lint:
           name: op-batcher-lint
@@ -1471,6 +1488,14 @@ workflows:
           docker_target: wd-mon
           context:
             - oplabs-gcr
+      - docker-publish:
+          name: fault-detector-docker-publish
+          docker_file: ./ops/docker/Dockerfile.packages
+          docker_name: fault-detector
+          docker_tags: <<pipeline.git.revision>>,<<pipeline.git.branch>>
+          docker_target: fault-detector
+          context:
+            - oplabs-gcr
       - hive-test:
           name: hive-test-rpc
           version: <<pipeline.git.revision>>
@@ -1504,7 +1529,7 @@ workflows:
           type: approval
           filters:
             tags:
-              only: /^(proxyd|op-[a-z0-9\-]*)\/v.*/
+              only: /^(fault-detector|proxyd|op-[a-z0-9\-]*)\/v.*/
             branches:
               ignore: /.*/
       - docker-release:
@@ -1571,6 +1596,23 @@ workflows:
             - oplabs-gcr-release
           requires:
             - hold
+      - docker-release:
+          name: fault-detector-docker-release
+          filters:
+            tags:
+              only: /^fault-detector\/v.*/
+            branches:
+              ignore: /.*/
+          docker_file: ./ops/docker/Dockerfile.packages
+          docker_name: fault-detector
+          docker_tags: <<pipeline.git.revision>>,<<pipeline.git.branch>>
+          docker_target: fault-detector
+          docker_context: .
+          platforms: "linux/amd64,linux/arm64"
+          context:
+            - oplabs-gcr-release
+          requires:
+            - hold
       - docker-build:
           name: op-migrate-docker-release
           filters:

.github/workflows/tag-service.yml

@@ -23,6 +23,7 @@ on:
           - op-proposer
           - proxyd
           - indexer
+          - fault-detector
       prerelease:
         description: Increment major/minor/patch as prerelease?
         required: false

indexer/services/l1/bridge/bridge.go

@@ -48,13 +48,6 @@ var customBridgeCfgs = map[uint64][]*implConfig{
 		{"DAI", "StandardBridge", common.HexToAddress("0x10E6593CDda8c58a1d0f14C5164B376352a55f2F")},
 		{"wstETH", "StandardBridge", common.HexToAddress("0x76943C0D61395d8F2edF9060e1533529cAe05dE6")},
 	},
-	// Kovan
-	42: {
-		{"BitBTC", "StandardBridge", common.HexToAddress("0x0b651A42F32069d62d5ECf4f2a7e5Bd3E9438746")},
-		{"USX", "StandardBridge", common.HexToAddress("0x40E862341b2416345F02c41Ac70df08525150dC7")},
-		{"DAI", "StandardBridge", common.HexToAddress("0xb415e822C4983ecD6B1c1596e8a5f976cf6CD9e3")},
-		{"wstETH", "StandardBridge", common.HexToAddress("0x65321bf24210b81500230dCEce14Faa70a9f50a7")},
-	},
 }
 
 func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, addrs services.AddressManager) (map[string]Bridge, error) {

indexer/services/l2/bridge/bridge.go

@@ -35,16 +35,9 @@ var customBridgeCfgs = map[uint64][]*implConfig{
 	// Mainnet
 	10: {
 		{"BitBTC", StandardBridgeImpl, common.HexToAddress("0x158F513096923fF2d3aab2BcF4478536de6725e2")},
-		//{"DAI", "DAIBridge", "0x467194771dAe2967Aef3ECbEDD3Bf9a310C76C65"},
+		{"DAI", StandardBridgeImpl, common.HexToAddress("0x467194771dAe2967Aef3ECbEDD3Bf9a310C76C65")},
 		{"wstETH", StandardBridgeImpl, common.HexToAddress("0x8E01013243a96601a86eb3153F0d9Fa4fbFb6957")},
 	},
-	// Kovan
-	69: {
-		{"BitBTC", StandardBridgeImpl, common.HexToAddress("0x0CFb46528a7002a7D8877a5F7a69b9AaF1A9058e")},
-		{"USX", StandardBridgeImpl, common.HexToAddress("0xB4d37826b14Cd3CB7257A2A5094507d701fe715f")},
-		{"wstETH", StandardBridgeImpl, common.HexToAddress("0x2E34e7d705AfaC3C4665b6feF31Aa394A1c81c92")},
-		//{"DAI", "	DAIBridge", "0x467194771dAe2967Aef3ECbEDD3Bf9a310C76C65"},
-	},
 }
 
 func BridgesByChainID(chainID *big.Int, client *ethclient.Client, isBedrock bool) (map[string]Bridge, error) {

op-chain-ops/Makefile

@@ -4,4 +4,10 @@ op-migrate:
 test:
 	go test ./...
 
+fuzz:
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz=FuzzEncodeDecodeWithdrawal ./crossdomain
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz=FuzzEncodeDecodeLegacyWithdrawal ./crossdomain
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz=FuzzAliasing ./crossdomain
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz=FuzzVersionedNonce ./crossdomain
+
 .PHONY: op-migrate test

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

@@ -164,8 +164,14 @@ func main() {
 			l1RpcURL := ctx.String("l1-rpc-url")
 			l1Client, err := ethclient.Dial(l1RpcURL)
 			if err != nil {
-				return err
+				return fmt.Errorf("cannot dial L1 client: %w", err)
+			}
+
+			chainId, err := l1Client.ChainID(context.Background())
+			if err != nil {
+				return fmt.Errorf("failed to get L1 ChainID: %w", err)
 			}
+			log.Info("L1 ChainID", "chainId", chainId)
 
 			var block *types.Block
 			tag := config.L1StartingBlockTag
@@ -181,14 +187,16 @@ func main() {
 				return fmt.Errorf("invalid l1StartingBlockTag in deploy config: %v", tag)
 			}
 			if err != nil {
-				return err
+				return fmt.Errorf("cannot fetch L1 starting block tag: %w", err)
 			}
 
 			dbCache := ctx.Int("db-cache")
 			dbHandles := ctx.Int("db-handles")
-			ldb, err := db.Open(ctx.String("db-path"), dbCache, dbHandles)
+			dbPath := ctx.String("db-path")
+			log.Info("Opening database", "dbCache", dbCache, "dbHandles", dbHandles, "dbPath", dbPath)
+			ldb, err := db.Open(dbPath, dbCache, dbHandles)
 			if err != nil {
-				return err
+				return fmt.Errorf("cannot open DB: %w", err)
 			}
 
 			// Read the required deployment addresses from disk if required
@@ -217,7 +225,7 @@ func main() {
 				return err
 			}
 
-			postLDB, err := db.Open(ctx.String("db-path"), dbCache, dbHandles)
+			postLDB, err := db.Open(dbPath, dbCache, dbHandles)
 			if err != nil {
 				return err
 			}

op-chain-ops/genesis/setters.go

 package genesis
 
 import (
+	"errors"
 	"fmt"
 	"math/big"
 
@@ -109,6 +110,9 @@ func setProxies(db vm.StateDB, proxyAdminAddr common.Address, namespace *big.Int
 	if err != nil {
 		return err
 	}
+	if len(depBytecode) == 0 {
+		return errors.New("Proxy has empty bytecode")
+	}
 
 	for i := uint64(0); i <= count; i++ {
 		bigAddr := new(big.Int).Or(namespace, new(big.Int).SetUint64(i))

ops/scripts/ci-docker-tag-op-stack-release.sh

@@ -6,7 +6,7 @@ DOCKER_REPO=$1
 GIT_TAG=$2
 GIT_SHA=$3
 
-IMAGE_NAME=$(echo "$GIT_TAG" | grep -Eow '^(proxyd|op-[a-z0-9\-]*)' || true)
+IMAGE_NAME=$(echo "$GIT_TAG" | grep -Eow '^(fault-detector|proxyd|op-[a-z0-9\-]*)' || true)
 if [ -z "$IMAGE_NAME" ]; then
   echo "image name could not be parsed from git tag '$GIT_TAG'"
   exit 1

ops/tag-service/tag-service.py

@@ -14,7 +14,8 @@ MIN_VERSIONS = {
     'op-batcher': '0.10.14',
     'op-proposer': '0.10.14',
     'proxyd': '3.16.0',
-    'indexer': '0.5.0'
+    'indexer': '0.5.0',
+    'fault-detector': '0.6.3'
 }
 
 VALID_BUMPS = ('major', 'minor', 'patch', 'prerelease', 'finalize-prerelease')

proxyd/backend.go

@@ -374,6 +374,7 @@ func (b *Backend) ForwardRPC(ctx context.Context, res *RPCRes, id string, method
 func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool) ([]*RPCRes, error) {
 	// we are concerned about network error rates, so we record 1 request independently of how many are in the batch
 	b.networkRequestsSlidingWindow.Incr()
+	RecordBackendNetworkRequestCountSlidingWindow(b, b.networkRequestsSlidingWindow.Count())
 
 	isSingleElementBatch := len(rpcReqs) == 1
 
@@ -390,6 +391,7 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 	httpReq, err := http.NewRequestWithContext(ctx, "POST", b.rpcURL, bytes.NewReader(body))
 	if err != nil {
 		b.networkErrorsSlidingWindow.Incr()
+		RecordBackendNetworkErrorCountSlidingWindow(b, b.networkErrorsSlidingWindow.Count())
 		return nil, wrapErr(err, "error creating backend request")
 	}
 
@@ -411,6 +413,7 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 	httpRes, err := b.client.DoLimited(httpReq)
 	if err != nil {
 		b.networkErrorsSlidingWindow.Incr()
+		RecordBackendNetworkErrorCountSlidingWindow(b, b.networkErrorsSlidingWindow.Count())
 		return nil, wrapErr(err, "error in backend request")
 	}
 
@@ -429,6 +432,7 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 	// Alchemy returns a 400 on bad JSONs, so handle that case
 	if httpRes.StatusCode != 200 && httpRes.StatusCode != 400 {
 		b.networkErrorsSlidingWindow.Incr()
+		RecordBackendNetworkErrorCountSlidingWindow(b, b.networkErrorsSlidingWindow.Count())
 		return nil, fmt.Errorf("response code %d", httpRes.StatusCode)
 	}
 
@@ -436,6 +440,7 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 	resB, err := io.ReadAll(io.LimitReader(httpRes.Body, b.maxResponseSize))
 	if err != nil {
 		b.networkErrorsSlidingWindow.Incr()
+		RecordBackendNetworkErrorCountSlidingWindow(b, b.networkErrorsSlidingWindow.Count())
 		return nil, wrapErr(err, "error reading response body")
 	}
 
@@ -453,15 +458,18 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 			// Infura may return a single JSON-RPC response if, for example, the batch contains a request for an unsupported method
 			if responseIsNotBatched(resB) {
 				b.networkErrorsSlidingWindow.Incr()
+				RecordBackendNetworkErrorCountSlidingWindow(b, b.networkErrorsSlidingWindow.Count())
 				return nil, ErrBackendUnexpectedJSONRPC
 			}
 			b.networkErrorsSlidingWindow.Incr()
+			RecordBackendNetworkErrorCountSlidingWindow(b, b.networkErrorsSlidingWindow.Count())
 			return nil, ErrBackendBadResponse
 		}
 	}
 
 	if len(rpcReqs) != len(res) {
 		b.networkErrorsSlidingWindow.Incr()
+		RecordBackendNetworkErrorCountSlidingWindow(b, b.networkErrorsSlidingWindow.Count())
 		return nil, ErrBackendUnexpectedJSONRPC
 	}
 
@@ -474,6 +482,7 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 	}
 	duration := time.Since(start)
 	b.latencySlidingWindow.Add(float64(duration))
+	RecordBackendNetworkLatencyAverageSlidingWindow(b, time.Duration(b.latencySlidingWindow.Avg()))
 
 	sortBatchRPCResponse(rpcReqs, res)
 	return res, nil

proxyd/metrics.go

@@ -309,6 +309,30 @@ var (
 	}, []string{
 		"backend_name",
 	})
+
+	avgLatencyBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: MetricsNamespace,
+		Name:      "backend_avg_latency",
+		Help:      "Average latency per backend",
+	}, []string{
+		"backend_name",
+	})
+
+	networkErrorCountBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: MetricsNamespace,
+		Name:      "backend_net_error_count",
+		Help:      "Network error count per backend",
+	}, []string{
+		"backend_name",
+	})
+
+	requestCountBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: MetricsNamespace,
+		Name:      "backend_request_count",
+		Help:      "Request count per backend",
+	}, []string{
+		"backend_name",
+	})
 )
 
 func RecordRedisError(source string) {
@@ -390,30 +414,42 @@ func RecordGroupTotalCount(group *BackendGroup, count int) {
 	consensusGroupTotalCount.WithLabelValues(group.Name).Set(float64(count))
 }
 
-func RecordBackendLatestBlock(be *Backend, blockNumber hexutil.Uint64) {
-	backendLatestBlockBackend.WithLabelValues(be.Name).Set(float64(blockNumber))
+func RecordBackendLatestBlock(b *Backend, blockNumber hexutil.Uint64) {
+	backendLatestBlockBackend.WithLabelValues(b.Name).Set(float64(blockNumber))
 }
 
-func RecordConsensusBackendBanned(be *Backend, banned bool) {
+func RecordConsensusBackendBanned(b *Backend, banned bool) {
 	v := float64(0)
 	if banned {
 		v = float64(1)
 	}
-	consensusBannedBackends.WithLabelValues(be.Name).Set(v)
+	consensusBannedBackends.WithLabelValues(b.Name).Set(v)
 }
 
-func RecordConsensusBackendPeerCount(be *Backend, peerCount uint64) {
-	consensusPeerCountBackend.WithLabelValues(be.Name).Set(float64(peerCount))
+func RecordConsensusBackendPeerCount(b *Backend, peerCount uint64) {
+	consensusPeerCountBackend.WithLabelValues(b.Name).Set(float64(peerCount))
 }
 
-func RecordConsensusBackendInSync(be *Backend, inSync bool) {
+func RecordConsensusBackendInSync(b *Backend, inSync bool) {
 	v := float64(0)
 	if inSync {
 		v = float64(1)
 	}
-	consensusInSyncBackend.WithLabelValues(be.Name).Set(v)
+	consensusInSyncBackend.WithLabelValues(b.Name).Set(v)
+}
+
+func RecordConsensusBackendUpdateDelay(b *Backend, delay time.Duration) {
+	consensusUpdateDelayBackend.WithLabelValues(b.Name).Set(float64(delay.Milliseconds()))
+}
+
+func RecordBackendNetworkLatencyAverageSlidingWindow(b *Backend, avgLatency time.Duration) {
+	avgLatencyBackend.WithLabelValues(b.Name).Set(float64(avgLatency.Milliseconds()))
+}
+
+func RecordBackendNetworkRequestCountSlidingWindow(b *Backend, count uint) {
+	requestCountBackend.WithLabelValues(b.Name).Set(float64(count))
 }
 
-func RecordConsensusBackendUpdateDelay(be *Backend, delay time.Duration) {
-	consensusUpdateDelayBackend.WithLabelValues(be.Name).Set(float64(delay.Milliseconds()))
+func RecordBackendNetworkErrorCountSlidingWindow(b *Backend, count uint) {
+	networkErrorCountBackend.WithLabelValues(b.Name).Set(float64(count))
 }

proxyd/rewriter.go

@@ -159,6 +159,13 @@ func rewriteTagMap(rctx RewriteContext, m map[string]interface{}, key string) (b
 }
 
 func rewriteTag(rctx RewriteContext, current string) (string, bool, error) {
+	// If a tag is the safe or finalized block number, don't rewrite it.
+	// We have a custom check here because the rpc.BlockNumberOrHash type
+	// doesn't support these custom tags yet.
+	if current == "safe" || current == "finalized" {
+		return current, false, nil
+	}
+
 	jv, err := json.Marshal(current)
 	if err != nil {
 		return "", false, err
@@ -177,5 +184,6 @@ func rewriteTag(rctx RewriteContext, current string) (string, bool, error) {
 			return "", false, ErrRewriteBlockOutOfRange
 		}
 	}
+
 	return current, false, nil
 }

proxyd/rewriter_test.go

@@ -308,6 +308,38 @@ func TestRewriteRequest(t *testing.T) {
 				require.Equal(t, hexutil.Uint64(100).String(), p[0])
 			},
 		},
+		{
+			name: "eth_getBlockByNumber finalized",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getBlockByNumber", Params: mustMarshalJSON([]string{"finalized"})},
+				res:  nil,
+			},
+			expected: RewriteNone,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 1, len(p))
+				require.Equal(t, "finalized", p[0])
+			},
+		},
+		{
+			name: "eth_getBlockByNumber safe",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getBlockByNumber", Params: mustMarshalJSON([]string{"safe"})},
+				res:  nil,
+			},
+			expected: RewriteNone,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 1, len(p))
+				require.Equal(t, "safe", p[0])
+			},
+		},
 		{
 			name: "eth_getBlockByNumber within range",
 			args: args{