Merge branch 'develop' into fix/release-readme

.changeset/clean-jars-check.md

----
-'@eth-optimism/data-transport-layer': patch
----
-
-Smaller filter query for searching for L1 start height. This number should be configured so that the search does not need to happen because using a smaller filter will cause it to take too long.

.changeset/empty-deers-buy.md

----
-'@eth-optimism/op-exporter': patch
----
-
-Fixes panic caused by version initialized to nil

.changeset/fair-starfishes-admire.md

----
-'@eth-optimism/gas-oracle': patch
-'@eth-optimism/contracts': patch
-'@eth-optimism/data-transport-layer': patch
----
-
-String update to change the system name from OE to Optimism

.changeset/beige-zoos-roll.md → .changeset/few-steaks-push.md

@@ -2,4 +2,4 @@
 '@eth-optimism/integration-tests': patch
 ---
 
-Updates to support nightly actor tests
+Add test coverage for zlib compressed batches

.changeset/flat-penguins-wave.md

+---
+'@eth-optimism/data-transport-layer': patch
+---
+
+Enable typed batch support

.changeset/heavy-bugs-mate.md

+---
+'@eth-optimism/batch-submitter': patch
+---
+
+Update to allow for zlib compressed batches

.changeset/mean-llamas-speak.md

----
-'@eth-optimism/message-relayer': patch
----
-
-Fix docker build

.changeset/poor-walls-do.md

+---
+'@eth-optimism/batch-submitter-service': patch
+---
+
+Move L2 dial logic out of bss-core to avoid l2geth dependency

.changeset/rare-onions-bathe.md

+---
+'@eth-optimism/integration-tests': patch
+---
+
+Replaces contract references in integration tests with SDK CrossChainMessenger objects.

.changeset/silent-keys-hunt.md

----
-'@eth-optimism/contracts': patch
----
-
-Remove legacy bin/deploy.ts script

.changeset/ten-rats-build.md

+---
+'@eth-optimism/batch-submitter-service': patch
+---
+
+Enable the usage of typed batches and type 0 zlib compressed batches

.changeset/thin-trees-matter.md

+---
+'@eth-optimism/core-utils': patch
+---
+
+Update batch serialization with typed batches and zlib compression

.circleci/config.yml

@@ -2,7 +2,7 @@ version: 2.1
 orbs:
   gcp-gke: circleci/gcp-gke@1.3.0
   slack: circleci/slack@4.5.1
-slack-fail-post-step: &slack-fail-post-step
+slack-nightly-build-fail-post-step: &slack-nightly-build-fail-post-step
   post-steps:
     - slack/notify:
         channel: $SLACK_DEFAULT_CHANNEL
@@ -141,6 +141,32 @@ jobs:
             kubectl rollout restart statefulset nightly-dtl --namespace nightly
             kubectl rollout restart deployment nightly-gas-oracle --namespace nightly
             kubectl rollout restart deployment edge-proxyd --namespace nightly
+  run-itests-nightly:
+    docker:
+      - image: cimg/base:2021.04
+    steps:
+      - setup_remote_docker:
+          version: 19.03.13
+      - run:
+          name: Run integration tests
+          command: |
+            docker run \
+              --env PRIVATE_KEY=$NIGHTLY_ITESTS_PRIVKEY \
+              --env L1_URL=https://nightly-l1.optimism-stacks.net \
+              --env L2_URL=https://nightly-l2.optimism-stacks.net \
+              --env ADDRESS_MANAGER=0xfcA6De8Db94C4d99bD5a7f5De1bb7A039265Ac42 \
+              --env L2_CHAINID=69 \
+              --env MOCHA_BAIL=true \
+              --env MOCHA_TIMEOUT=300000 \
+              --env L1_GAS_PRICE=onchain \
+              --env L2_GAS_PRICE=onchain \
+              --env RUN_DEBUG_TRACE_TESTS=false \
+              --env RUN_REPLICA_TESTS=false \
+              --env RUN_STRESS_TESTS=false \
+              --env OVMCONTEXT_SPEC_NUM_TXS=1 \
+              --env DTL_ENQUEUE_CONFIRMATIONS=12 \
+              "$STACKMAN_REPO/integration-tests:nightly" \
+              yarn test:integration:live
   notify:
     docker:
       - image: cimg/base:2021.04
@@ -152,6 +178,78 @@ jobs:
 
 
 workflows:
+  nightly-itests:
+    triggers:
+      - schedule:
+          cron: "0 1 * * * "
+          filters:
+            branches:
+              only:
+                - develop
+    jobs:
+      - run-itests-nightly:
+          context:
+            - optimism
+          post-steps:
+            - slack/notify:
+                channel: $SLACK_DEFAULT_CHANNEL
+                event: fail
+                custom: |
+                  {
+                    "text": "",
+                    "blocks": [
+                      {
+                        "type": "section",
+                        "text": {
+                          "type": "mrkdwn",
+                          "text": "🔴 Nightly integration tests failed!"
+                        }
+                      },
+                      {
+                        "type": "actions",
+                        "elements": [
+                          {
+                            "type": "button",
+                            "text": {
+                              "type": "plain_text",
+                              "text": "View Job"
+                            },
+                            "url": "${CIRCLE_BUILD_URL}"
+                          }
+                        ]
+                      }
+                    ]
+                  }
+            - slack/notify:
+                channel: $SLACK_DEFAULT_CHANNEL
+                event: pass
+                custom: |
+                  {
+                    "text": "",
+                    "blocks": [
+                      {
+                        "type": "section",
+                        "text": {
+                          "type": "mrkdwn",
+                          "text": "✅ Nightly integration tests passed."
+                        }
+                      },
+                      {
+                        "type": "actions",
+                        "elements": [
+                          {
+                            "type": "button",
+                            "text": {
+                              "type": "plain_text",
+                              "text": "View Job"
+                            },
+                            "url": "${CIRCLE_BUILD_URL}"
+                          }
+                        ]
+                      }
+                    ]
+                  }
+
   nightly:
     triggers:
       - schedule:
@@ -165,47 +263,47 @@ workflows:
           context: 
             - optimism
             - slack
-          <<: *slack-fail-post-step
+          <<: *slack-nightly-build-fail-post-step
       - build-batch-submitter:
           context:
             - optimism
             - slack
-          <<: *slack-fail-post-step
+          <<: *slack-nightly-build-fail-post-step
       - build-deployer:
           context:
             - optimism
             - slack
-          <<: *slack-fail-post-step
+          <<: *slack-nightly-build-fail-post-step
       - build-l2geth:
           context:
             - optimism
             - slack
-          <<: *slack-fail-post-step
+          <<: *slack-nightly-build-fail-post-step
       - build-gas-oracle:
           context:
             - optimism
             - slack
-          <<: *slack-fail-post-step
+          <<: *slack-nightly-build-fail-post-step
       - build-integration-tests:
           context:
             - optimism
             - slack
-          <<: *slack-fail-post-step
+          <<: *slack-nightly-build-fail-post-step
       - build-go-batch-submitter:
           context:
             - optimism
             - slack
-          <<: *slack-fail-post-step
+          <<: *slack-nightly-build-fail-post-step
       - build-proxyd:
           context:
             - optimism
             - slack
-          <<: *slack-fail-post-step
+          <<: *slack-nightly-build-fail-post-step
       - deploy-nightly:
           context:
             - optimism
             - slack
-          <<: *slack-fail-post-step
+          <<: *slack-nightly-build-fail-post-step
           requires:
             - build-dtl
             - build-batch-submitter

.dockerignore

 .github
 
 node_modules
+.env
+**/.env
 
 test
 **/*_test.go
@@ -12,3 +14,4 @@ l2geth/signer/fourbyte
 l2geth/cmd/puppeth
 l2geth/cmd/clef
 go/gas-oracle/gas-oracle
+go/batch-submitter/batch-submitter

.eslintrc.js

@@ -101,7 +101,17 @@ module.exports = {
     'id-match': 'off',
     'import/no-extraneous-dependencies': ['error'],
     'import/no-internal-modules': 'off',
-    'import/order': 'off',
+    'import/order': [
+      "error",
+      {
+        groups: [
+          'builtin',
+          'external',
+          'internal',
+        ],
+        'newlines-between': 'always',
+      },
+    ],
     indent: 'off',
     'jsdoc/check-alignment': 'error',
     'jsdoc/check-indentation': 'error',

.github/labeler.yml

@@ -30,5 +30,8 @@ M-core-utils:
 M-dtl:
   - any: ['packages/data-transport-layer/**/*']
 
+M-sdk:
+  - any: ['packages/sdk/**/*']
+
 M-ops:
   - any: ['ops/**/*']

.github/workflows/batch-submitter.yml

@@ -10,8 +10,8 @@ on:
       - '*rc'
       - 'regenesis/*'
   pull_request:
-    paths:
-      - 'go/batch-submitter/*'
+    branches:
+      - '*'
   workflow_dispatch:
 
 defaults:

.github/workflows/bss-core.yml

+name: bss-core unit tests
+
+on:
+  push:
+    paths:
+      - 'go/bss-core/**'
+    branches:
+      - 'master'
+      - 'develop'
+      - '*rc'
+      - 'regenesis/*'
+  pull_request:
+    branches:
+      - '*'
+  workflow_dispatch:
+
+defaults:
+  run:
+    working-directory: './go/bss-core'
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Install Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.16.x
+
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Test
+        run: go test -v ./...

.github/workflows/gas-oracle.yml

@@ -10,8 +10,8 @@ on:
       - '*rc'
       - 'regenesis/*'
   pull_request:
-    paths:
-      - 'go/gas-oracle/**'
+    branches:
+      - '*'
   workflow_dispatch:
 
 defaults:

.github/workflows/golangci-lint.yml

@@ -4,15 +4,16 @@ on:
     paths:
       - 'go/gas-oracle/**'
       - 'go/batch-submitter/**'
+      - 'go/bss-core/**'
+      - 'go/teleportr/**'
     branches:
       - 'master'
       - 'develop'
       - '*rc'
       - 'regenesis/*'
   pull_request:
-    paths:
-      - 'go/gas-oracle/**'
-      - 'go/batch-submitter/**'
+    branches:
+      - '*'
 jobs:
   golangci:
     name: lint
@@ -29,3 +30,13 @@ jobs:
         with:
           version: v1.29
           working-directory: go/batch-submitter
+      - name: golangci-lint bss-core
+        uses: golangci/golangci-lint-action@v2
+        with:
+          version: v1.29
+          working-directory: go/bss-core
+      - name: golangci-lint teleportr
+        uses: golangci/golangci-lint-action@v2
+        with:
+          version: v1.29
+          working-directory: go/teleportr

.github/workflows/integration.yml

@@ -20,10 +20,15 @@ jobs:
           - 5000:5000
     strategy:
       matrix:
-        batch-submitter: [ts-batch-submitter, go-batch-submitter]
+        batch-submitter:
+          - ts-batch-submitter
+          - go-batch-submitter
+        batch-type:
+          - zlib
+          - legacy
     env:
-        DOCKER_BUILDKIT: 1
-        COMPOSE_DOCKER_CLI_BUILD: 1
+      DOCKER_BUILDKIT: 1
+      COMPOSE_DOCKER_CLI_BUILD: 1
     steps:
       # Monorepo tests
       - uses: actions/checkout@v2
@@ -40,6 +45,10 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-yarn-
 
+      - name: Set conditional env vars
+        run: |
+          echo "BATCH_SUBMITTER_SEQUENCER_BATCH_TYPE=${{ matrix.batch-type }}" >> $GITHUB_ENV
+
       - name: Bring the stack up
         working-directory: ./ops
         run: |

.github/workflows/label-requires-reviews.yml

@@ -13,4 +13,4 @@ jobs:
       - name: Require-reviewers
         uses: travelperk/label-requires-reviews-action@v0.1
         env:
-          GITHUB_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN}}
\ No newline at end of file
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/proxyd.yml

+name: proxyd unit tests
+
+on:
+  push:
+    branches:
+      - 'master'
+      - 'develop'
+  pull_request:
+    branches:
+      - '*'
+  workflow_dispatch:
+
+defaults:
+  run:
+    working-directory: ./go/proxyd
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Install Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.15.x
+
+    - name: Checkout code
+      uses: actions/checkout@v2
+
+    - name: Build
+      run: make proxyd
+
+    - name: Lint
+      run: make lint
+
+    - name: Test
+      run: make test

.github/workflows/publish-canary.yml

@@ -29,6 +29,7 @@ jobs:
       rpc-proxy : ${{ steps.packages.outputs.rpc-proxy }}
       op-exporter : ${{ steps.packages.outputs.op-exporter }}
       l2geth-exporter : ${{ steps.packages.outputs.l2geth-exporter }}
+      batch-submitter-service : ${{ steps.packages.outputs.batch-submitter-service }}
 
     steps:
       - name: Check out source code
@@ -64,7 +65,7 @@ jobs:
         run: yarn changeset version --snapshot
 
       - name: Publish To NPM
-        uses: changesets/action@master
+        uses: changesets/action@v1
         id: changesets
         with:
           publish: yarn changeset publish --tag canary
@@ -506,3 +507,29 @@ jobs:
           file: ./ops/docker/Dockerfile.rpc-proxy
           push: true
           tags: ethereumoptimism/rpc-proxy:${{ needs.canary-publish.outputs.rpc-proxy }}
+
+  batch-submitter-service:
+    name: Publish batch-submitter-service Version ${{ needs.canary-publish.outputs.canary-docker-tag }}
+    needs: canary-publish
+    if: needs.canary-publish.outputs.batch-submitter-service != ''
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKERHUB_ACCESS_TOKEN_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_ACCESS_TOKEN_SECRET }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./ops/docker/Dockerfile.batch-submitter-service
+          push: true
+          tags: ethereumoptimism/batch-submitter-service:${{ needs.canary-publish.outputs.batch-submitter-service }}

.github/workflows/release.yml

@@ -25,6 +25,7 @@ jobs:
       hardhat-node: ${{ steps.packages.outputs.hardhat-node }}
       op-exporter : ${{ steps.packages.outputs.op-exporter }}
       l2geth-exporter : ${{ steps.packages.outputs.l2geth-exporter }}
+      batch-submitter-service : ${{ steps.packages.outputs.batch-submitter-service }}
 
     steps:
       - name: Checkout Repo
@@ -54,7 +55,7 @@ jobs:
         run: yarn
 
       - name: Publish To NPM or Create Release Pull Request
-        uses: changesets/action@master
+        uses: changesets/action@v1
         id: changesets
         with:
           publish: yarn release
@@ -100,14 +101,6 @@ jobs:
           push: true
           tags: ethereumoptimism/l2geth:${{ needs.release.outputs.l2geth }},ethereumoptimism/l2geth:latest
 
-      - name: Publish rpc-proxy
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          file: ./ops/docker/Dockerfile.rpc-proxy
-          push: true
-          tags: ethereumoptimism/rpc-proxy:${{ needs.release.outputs.l2geth }},ethereumoptimism/rpc-proxy:latest
-
   gas-oracle:
     name: Publish Gas Oracle Version ${{ needs.release.outputs.gas-oracle }}
     needs: release
@@ -502,3 +495,29 @@ jobs:
           push: true
           tags: ethereumoptimism/replica-healthcheck:${{ needs.builder.outputs.replica-healthcheck }},ethereumoptimism/replica-healthcheck:latest
           build-args: BUILDER_TAG=${{ needs.builder.outputs.builder }}
+
+  batch-submitter-service:
+    name: Publish batch-submitter-service Version ${{ needs.release.outputs.batch-submitter-service }}
+    needs: release
+    if: needs.release.outputs.batch-submitter-service != ''
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKERHUB_ACCESS_TOKEN_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_ACCESS_TOKEN_SECRET }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./ops/docker/Dockerfile.batch-submitter-service
+          push: true
+          tags: ethereumoptimism/batch-submitter-service:${{ needs.release.outputs.batch-submitter-service }},ethereumoptimism/batch-submitter-service:latest

.github/workflows/teleportr.yml

+name: teleportr unit tests
+
+on:
+  push:
+    paths:
+      - 'go/teleportr/**'
+    branches:
+      - 'master'
+      - 'develop'
+      - '*rc'
+      - 'regenesis/*'
+  pull_request:
+    branches:
+      - '*'
+  workflow_dispatch:
+
+defaults:
+  run:
+    working-directory: './go/teleportr'
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: password
+        ports:
+          - 5432:5432
+    steps:
+      - name: Install Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.16.x
+
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Test
+        run: go test -v ./...

.github/workflows/ts-packages.yml

@@ -138,6 +138,66 @@ jobs:
           verbose: true
           flags: sdk
 
+  depcheck:
+    name: Check for unused dependencies
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Fetch history
+        run: git fetch
+
+      - name: Setup node
+        uses: actions/setup-node@v1
+        with:
+          node-version: '16.x'
+
+      - name: Get yarn cache directory path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn cache dir)"
+
+      - uses: actions/cache@v2
+        id: yarn-cache
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+
+      - name: Install Dependencies
+        # only install dependencies if there was a change in the deps
+        # if: steps.yarn-cache.outputs.cache-hit != 'true'
+        run: yarn install
+
+      - name: Check packages/batch-submitter
+        working-directory: ./packages/batch-submitter
+        run: npx depcheck
+
+      - name: Check packages/contracts
+        working-directory: ./packages/contracts
+        run: npx depcheck
+
+      - name: Check packages/core-utils
+        working-directory: ./packages/core-utils
+        run: npx depcheck
+
+      - name: Check packages/data-transport-layer
+        working-directory: ./packages/data-transport-layer
+        run: npx depcheck
+
+      - name: Check packages/message-relayer
+        working-directory: ./packages/message-relayer
+        run: npx depcheck
+
+      - name: Check packages/sdk
+        working-directory: ./packages/sdk
+        run: npx depcheck
+
+      - name: Check integration-tests
+        working-directory: ./integration-tests
+        run: npx depcheck
+
   lint:
     name: Linting
     runs-on: ubuntu-latest

.gitignore

@@ -20,7 +20,7 @@ packages/contracts/hardhat*
 packages/data-transport-layer/db
 
 # vim
-*.swp
+*.sw*
 
 .env
 .env*

README.md

@@ -38,6 +38,11 @@ root
 │   ├── <a href="./packages/batch-submitter">batch-submitter</a>: Service for submitting batches of transactions and results to L1
 │   ├── <a href="./packages/message-relayer">message-relayer</a>: Tool for automatically relaying L1<>L2 messages in development
 │   └── <a href="./packages/replica-healthcheck">replica-healthcheck</a>: Service for monitoring the health of a replica node
+├── <a href="./go">go</a>
+│   ├── <a href="./go/batch-submitter">batch-submitter</a>: Service for submitting batches of transactions and results to L1
+│   ├── <a href="./go/bss-core">bss-core</a>: Core batch-submitter logic and utilities
+│   ├── <a href="./go/gas-oracle">gas-oracle</a>: Service for updating L1 gas prices on L2
+│   └── <a href="./go/proxyd">proxyd</a>: Configurable RPC request router and proxy
 ├── <a href="./l2geth">l2geth</a>: Optimism client software, a fork of <a href="https://github.com/ethereum/go-ethereum/tree/v1.9.10">geth v1.9.10</a>
 ├── <a href="./integration-tests">integration-tests</a>: Various integration tests for the Optimism network
 └── <a href="./ops">ops</a>: Tools for running Optimism nodes and networks
@@ -92,6 +97,10 @@ Release candidates are merged into `develop` and then into `master` once they've
 We may sometimes have more than one active `regenesis/X.X.X` branch if we're in the middle of a deployment.
 See table in the **Active Branches** section above to find the right branch to target.
 
+### Releasing new versions
+
+Developers can release new versions of the software by adding changesets to their pull requests using `yarn changeset`. Changesets will persist over time on the `develop` branch without triggering new version bumps to be proposed by the Changesets bot. Once changesets are merged into `master`, the bot will create a new pull request called "Version Packages" which bumps the versions of packages. The correct flow for triggering releases is to re-base these pull requests onto `develop` and merge them, and then create a new pull request to merge `develop` onto `master`. Then, the `release` workflow will trigger the actual publishing to `npm` and Docker hub.
+
 ## License
 
 Code forked from [`go-ethereum`](https://github.com/ethereum/go-ethereum) under the name [`l2geth`](https://github.com/ethereum-optimism/optimism/tree/master/l2geth) is licensed under the [GNU GPLv3](https://gist.github.com/kn9ts/cbe95340d29fc1aaeaa5dd5c059d2e60) in accordance with the [original license](https://github.com/ethereum/go-ethereum/blob/master/COPYING).

go/batch-submitter/CHANGELOG.md

 # @eth-optimism/batch-submitter-service
 
+## 0.1.5
+
+### Patch Changes
+
+- 6f2ea193: Update to go-ethereum v1.10.16
+- 87359fd2: Refactors the bss-core service to use a metrics interface to allow
+  driver-specific metric extensions
+
+## 0.1.4
+
+### Patch Changes
+
+- bcbde5f3: Fixes a bug that causes the txmgr to not wait for the configured numConfirmations
+
+## 0.1.3
+
+### Patch Changes
+
+- 69118ac3: Switch num_elements_per_batch from Histogram to Summary
+- df98d134: Remove extra space in metric names
+- 3ec06301: Default to JSON logs, add LOG_TERMINAL flag for debugging
+- fe321618: Unify metric name format
+- 93a26819: Fixes a bug where clearing txs are rejected on startup due to missing gas limit
+
+## 0.1.2
+
+### Patch Changes
+
+- c775ffbe: fix BSS log-level flag parsing
+- d093a6bb: Adds a fix for the BSS to account for the new timestamp logic in L2Geth
+- d4c2e01b: Restructure to use bss-core package
+
+## 0.1.1
+
+### Patch Changes
+
+- 5905f3dc: Update golang version to support HTTP/2
+- c1eba2e6: use EIP-1559 txns for tx/state batches
+
+## 0.1.0
+
+### Minor Changes
+
+- 356b7271: Add multi-tx support, clear pending txs on startup
+
+### Patch Changes
+
+- 85aa148d: Adds confirmation depth awareness to txmgr
+
 ## 0.0.2
+
 ### Patch Changes
 
 - d6e0de5a: Fix metrics server

go/batch-submitter/cmd/batch-submitter/main.go

@@ -20,7 +20,7 @@ var (
 
 func main() {
 	// Set up logger with a default INFO level in case we fail to parse flags.
-	// Otherwise the final crtiical log won't show what the parsing error was.
+	// Otherwise the final critical log won't show what the parsing error was.
 	log.Root().SetHandler(
 		log.LvlFilterHandler(
 			log.LvlInfo,

go/batch-submitter/config.go

@@ -33,6 +33,11 @@ var (
 	ErrSameSequencerAndProposerPrivKey = errors.New("sequencer-priv-key and " +
 		"proposer-priv-key must be distinct")
 
+	// ErrInvalidBatchType  signals that an unsupported batch type is being
+	// configured. The default is "legacy" and the options are "legacy" or
+	// "zlib"
+	ErrInvalidBatchType = errors.New("invalid batch type")
+
 	// ErrSentryDSNNotSet signals that not Data Source Name was provided
 	// with which to configure Sentry logging.
 	ErrSentryDSNNotSet = errors.New("sentry-dsn must be set if use-sentry " +
@@ -89,6 +94,11 @@ type Config struct {
 	// appending new batches.
 	NumConfirmations uint64
 
+	// SafeAbortNonceTooLowCount is the number of ErrNonceTooLowObservations
+	// required to give up on a tx at a particular nonce without receiving
+	// confirmation.
+	SafeAbortNonceTooLowCount uint64
+
 	// ResubmissionTimeout is time we will wait before resubmitting a
 	// transaction.
 	ResubmissionTimeout time.Duration
@@ -118,6 +128,11 @@ type Config struct {
 	// LogLevel is the lowest log level that will be output.
 	LogLevel string
 
+	// LogTerminal if true, prints to stdout in terminal format, otherwise
+	// prints using JSON. If SentryEnable is true this flag is ignored, and logs
+	// are printed using JSON.
+	LogTerminal bool
+
 	// SentryEnable if true, logs any error messages to sentry. SentryDsn
 	// must also be set if SentryEnable is true.
 	SentryEnable bool
@@ -133,14 +148,6 @@ type Config struct {
 	// blocks.
 	BlockOffset uint64
 
-	// MaxGasPriceInGwei is the maximum gas price in gwei we will allow in order
-	// to confirm a transaction.
-	MaxGasPriceInGwei uint64
-
-	// GasRetryIncrement is the step size (in gwei) by which we will ratchet the
-	// gas price in order to get a transaction confirmed.
-	GasRetryIncrement uint64
-
 	// SequencerPrivateKey the private key of the wallet used to submit
 	// transactions to the CTC contract.
 	SequencerPrivateKey string
@@ -162,6 +169,9 @@ type Config struct {
 	// the proposer transactions.
 	ProposerHDPath string
 
+	// SequencerBatchType represents the type of batch the sequencer submits.
+	SequencerBatchType string
+
 	// MetricsServerEnable if true, will create a metrics client and log to
 	// Prometheus.
 	MetricsServerEnable bool
@@ -171,6 +181,9 @@ type Config struct {
 
 	// MetricsPort is the port at which the metrics server is running.
 	MetricsPort uint64
+
+	// DisableHTTP2 disables HTTP2 support.
+	DisableHTTP2 bool
 }
 
 // NewConfig parses the Config from the provided flags or environment variables.
@@ -178,37 +191,40 @@ type Config struct {
 func NewConfig(ctx *cli.Context) (Config, error) {
 	cfg := Config{
 		/* Required Flags */
-		BuildEnv:                ctx.GlobalString(flags.BuildEnvFlag.Name),
-		EthNetworkName:          ctx.GlobalString(flags.EthNetworkNameFlag.Name),
-		L1EthRpc:                ctx.GlobalString(flags.L1EthRpcFlag.Name),
-		L2EthRpc:                ctx.GlobalString(flags.L2EthRpcFlag.Name),
-		CTCAddress:              ctx.GlobalString(flags.CTCAddressFlag.Name),
-		SCCAddress:              ctx.GlobalString(flags.SCCAddressFlag.Name),
-		MaxL1TxSize:             ctx.GlobalUint64(flags.MaxL1TxSizeFlag.Name),
-		MaxBatchSubmissionTime:  ctx.GlobalDuration(flags.MaxBatchSubmissionTimeFlag.Name),
-		PollInterval:            ctx.GlobalDuration(flags.PollIntervalFlag.Name),
-		NumConfirmations:        ctx.GlobalUint64(flags.NumConfirmationsFlag.Name),
-		ResubmissionTimeout:     ctx.GlobalDuration(flags.ResubmissionTimeoutFlag.Name),
-		FinalityConfirmations:   ctx.GlobalUint64(flags.FinalityConfirmationsFlag.Name),
-		RunTxBatchSubmitter:     ctx.GlobalBool(flags.RunTxBatchSubmitterFlag.Name),
-		RunStateBatchSubmitter:  ctx.GlobalBool(flags.RunStateBatchSubmitterFlag.Name),
-		SafeMinimumEtherBalance: ctx.GlobalUint64(flags.SafeMinimumEtherBalanceFlag.Name),
-		ClearPendingTxs:         ctx.GlobalBool(flags.ClearPendingTxsFlag.Name),
+		BuildEnv:                  ctx.GlobalString(flags.BuildEnvFlag.Name),
+		EthNetworkName:            ctx.GlobalString(flags.EthNetworkNameFlag.Name),
+		L1EthRpc:                  ctx.GlobalString(flags.L1EthRpcFlag.Name),
+		L2EthRpc:                  ctx.GlobalString(flags.L2EthRpcFlag.Name),
+		CTCAddress:                ctx.GlobalString(flags.CTCAddressFlag.Name),
+		SCCAddress:                ctx.GlobalString(flags.SCCAddressFlag.Name),
+		MaxL1TxSize:               ctx.GlobalUint64(flags.MaxL1TxSizeFlag.Name),
+		MaxBatchSubmissionTime:    ctx.GlobalDuration(flags.MaxBatchSubmissionTimeFlag.Name),
+		PollInterval:              ctx.GlobalDuration(flags.PollIntervalFlag.Name),
+		NumConfirmations:          ctx.GlobalUint64(flags.NumConfirmationsFlag.Name),
+		SafeAbortNonceTooLowCount: ctx.GlobalUint64(flags.SafeAbortNonceTooLowCountFlag.Name),
+		ResubmissionTimeout:       ctx.GlobalDuration(flags.ResubmissionTimeoutFlag.Name),
+		FinalityConfirmations:     ctx.GlobalUint64(flags.FinalityConfirmationsFlag.Name),
+		RunTxBatchSubmitter:       ctx.GlobalBool(flags.RunTxBatchSubmitterFlag.Name),
+		RunStateBatchSubmitter:    ctx.GlobalBool(flags.RunStateBatchSubmitterFlag.Name),
+		SafeMinimumEtherBalance:   ctx.GlobalUint64(flags.SafeMinimumEtherBalanceFlag.Name),
+		ClearPendingTxs:           ctx.GlobalBool(flags.ClearPendingTxsFlag.Name),
 		/* Optional Flags */
+		LogLevel:            ctx.GlobalString(flags.LogLevelFlag.Name),
+		LogTerminal:         ctx.GlobalBool(flags.LogTerminalFlag.Name),
 		SentryEnable:        ctx.GlobalBool(flags.SentryEnableFlag.Name),
 		SentryDsn:           ctx.GlobalString(flags.SentryDsnFlag.Name),
 		SentryTraceRate:     ctx.GlobalDuration(flags.SentryTraceRateFlag.Name),
 		BlockOffset:         ctx.GlobalUint64(flags.BlockOffsetFlag.Name),
-		MaxGasPriceInGwei:   ctx.GlobalUint64(flags.MaxGasPriceInGweiFlag.Name),
-		GasRetryIncrement:   ctx.GlobalUint64(flags.GasRetryIncrementFlag.Name),
 		SequencerPrivateKey: ctx.GlobalString(flags.SequencerPrivateKeyFlag.Name),
 		ProposerPrivateKey:  ctx.GlobalString(flags.ProposerPrivateKeyFlag.Name),
 		Mnemonic:            ctx.GlobalString(flags.MnemonicFlag.Name),
 		SequencerHDPath:     ctx.GlobalString(flags.SequencerHDPathFlag.Name),
 		ProposerHDPath:      ctx.GlobalString(flags.ProposerHDPathFlag.Name),
+		SequencerBatchType:  ctx.GlobalString(flags.SequencerBatchType.Name),
 		MetricsServerEnable: ctx.GlobalBool(flags.MetricsServerEnableFlag.Name),
 		MetricsHostname:     ctx.GlobalString(flags.MetricsHostnameFlag.Name),
 		MetricsPort:         ctx.GlobalUint64(flags.MetricsPortFlag.Name),
+		DisableHTTP2:        ctx.GlobalBool(flags.HTTP2DisableFlag.Name),
 	}
 
 	err := ValidateConfig(&cfg)
@@ -223,10 +239,6 @@ func NewConfig(ctx *cli.Context) (Config, error) {
 // ensure that it is well-formed.
 func ValidateConfig(cfg *Config) error {
 	// Sanity check log level.
-	if cfg.LogLevel == "" {
-		cfg.LogLevel = "debug"
-	}
-
 	_, err := log.LvlFromString(cfg.LogLevel)
 	if err != nil {
 		return err
@@ -262,6 +274,12 @@ func ValidateConfig(cfg *Config) error {
 		return ErrSameSequencerAndProposerPrivKey
 	}
 
+	usingTypedBatches := cfg.SequencerBatchType != ""
+	validBatchType := cfg.SequencerBatchType == "legacy" || cfg.SequencerBatchType == "zlib"
+	if usingTypedBatches && !validBatchType {
+		return ErrInvalidBatchType
+	}
+
 	// Ensure the Sentry Data Source Name is set when using Sentry.
 	if cfg.SentryEnable && cfg.SentryDsn == "" {
 		return ErrSentryDSNNotSet

go/batch-submitter/dial_l2_client.go

+package batchsubmitter
+
+import (
+	"context"
+	"crypto/tls"
+	"net/http"
+	"strings"
+
+	"github.com/ethereum-optimism/optimism/go/bss-core/dial"
+	"github.com/ethereum-optimism/optimism/l2geth/ethclient"
+	"github.com/ethereum-optimism/optimism/l2geth/log"
+	"github.com/ethereum-optimism/optimism/l2geth/rpc"
+)
+
+// DialL2EthClientWithTimeout attempts to dial the L2 provider using the
+// provided URL. If the dial doesn't complete within dial.DefaultTimeout seconds,
+// this method will return an error.
+func DialL2EthClientWithTimeout(ctx context.Context, url string, disableHTTP2 bool) (
+	*ethclient.Client, error) {
+
+	ctxt, cancel := context.WithTimeout(ctx, dial.DefaultTimeout)
+	defer cancel()
+
+	if strings.HasPrefix(url, "http") {
+		httpClient := new(http.Client)
+		if disableHTTP2 {
+			log.Info("Disabled HTTP/2 support in L2 eth client")
+			httpClient.Transport = &http.Transport{
+				TLSNextProto: make(map[string]func(authority string, c *tls.Conn) http.RoundTripper),
+			}
+		}
+
+		rpcClient, err := rpc.DialHTTPWithClient(url, httpClient)
+		if err != nil {
+			return nil, err
+		}
+
+		return ethclient.NewClient(rpcClient), nil
+	}
+
+	return ethclient.DialContext(ctxt, url)
+}

go/batch-submitter/drivers/proposer/driver.go

@@ -5,13 +5,16 @@ import (
 	"crypto/ecdsa"
 	"fmt"
 	"math/big"
-	"time"
+	"strings"
 
 	"github.com/ethereum-optimism/optimism/go/batch-submitter/bindings/ctc"
 	"github.com/ethereum-optimism/optimism/go/batch-submitter/bindings/scc"
-	"github.com/ethereum-optimism/optimism/go/batch-submitter/metrics"
-	l2types "github.com/ethereum-optimism/optimism/l2geth/core/types"
+	"github.com/ethereum-optimism/optimism/go/bss-core/drivers"
+	"github.com/ethereum-optimism/optimism/go/bss-core/metrics"
+	"github.com/ethereum-optimism/optimism/go/bss-core/txmgr"
 	l2ethclient "github.com/ethereum-optimism/optimism/l2geth/ethclient"
+	"github.com/ethereum-optimism/optimism/l2geth/log"
+	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -19,6 +22,9 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 )
 
+// stateRootSize is the size in bytes of a state root.
+const stateRootSize = 32
+
 var bigOne = new(big.Int).SetUint64(1) //nolint:unused
 
 type Config struct {
@@ -34,11 +40,12 @@ type Config struct {
 }
 
 type Driver struct {
-	cfg         Config
-	sccContract *scc.StateCommitmentChain
-	ctcContract *ctc.CanonicalTransactionChain
-	walletAddr  common.Address
-	metrics     *metrics.Metrics
+	cfg            Config
+	sccContract    *scc.StateCommitmentChain
+	rawSccContract *bind.BoundContract
+	ctcContract    *ctc.CanonicalTransactionChain
+	walletAddr     common.Address
+	metrics        *metrics.Base
 }
 
 func NewDriver(cfg Config) (*Driver, error) {
@@ -56,14 +63,26 @@ func NewDriver(cfg Config) (*Driver, error) {
 		return nil, err
 	}
 
+	parsed, err := abi.JSON(strings.NewReader(
+		scc.StateCommitmentChainABI,
+	))
+	if err != nil {
+		return nil, err
+	}
+
+	rawSccContract := bind.NewBoundContract(
+		cfg.SCCAddr, parsed, cfg.L1Client, cfg.L1Client, cfg.L1Client,
+	)
+
 	walletAddr := crypto.PubkeyToAddress(cfg.PrivKey.PublicKey)
 
 	return &Driver{
-		cfg:         cfg,
-		sccContract: sccContract,
-		ctcContract: ctcContract,
-		walletAddr:  walletAddr,
-		metrics:     metrics.NewMetrics(cfg.Name),
+		cfg:            cfg,
+		sccContract:    sccContract,
+		rawSccContract: rawSccContract,
+		ctcContract:    ctcContract,
+		walletAddr:     walletAddr,
+		metrics:        metrics.NewBase("batch_submitter", cfg.Name),
 	}, nil
 }
 
@@ -78,10 +97,25 @@ func (d *Driver) WalletAddr() common.Address {
 }
 
 // Metrics returns the subservice telemetry object.
-func (d *Driver) Metrics() *metrics.Metrics {
+func (d *Driver) Metrics() metrics.Metrics {
 	return d.metrics
 }
 
+// ClearPendingTx a publishes a transaction at the next available nonce in order
+// to clear any transactions in the mempool left over from a prior running
+// instance of the batch submitter.
+func (d *Driver) ClearPendingTx(
+	ctx context.Context,
+	txMgr txmgr.TxManager,
+	l1Client *ethclient.Client,
+) error {
+
+	return drivers.ClearPendingTx(
+		d.cfg.Name, ctx, txMgr, l1Client, d.walletAddr, d.cfg.PrivKey,
+		d.cfg.ChainID,
+	)
+}
+
 // GetBatchBlockRange returns the start and end L2 block heights that need to be
 // processed. Note that the end value is *exclusive*, therefore if the returned
 // values are identical nothing needs to be processed.
@@ -89,7 +123,6 @@ func (d *Driver) GetBatchBlockRange(
 	ctx context.Context) (*big.Int, *big.Int, error) {
 
 	blockOffset := new(big.Int).SetUint64(d.cfg.BlockOffset)
-	maxBatchSize := new(big.Int).SetUint64(1)
 
 	start, err := d.sccContract.GetTotalElements(&bind.CallOpts{
 		Pending: false,
@@ -100,20 +133,14 @@ func (d *Driver) GetBatchBlockRange(
 	}
 	start.Add(start, blockOffset)
 
-	totalElements, err := d.ctcContract.GetTotalElements(&bind.CallOpts{
+	end, err := d.ctcContract.GetTotalElements(&bind.CallOpts{
 		Pending: false,
 		Context: ctx,
 	})
 	if err != nil {
 		return nil, nil, err
 	}
-	totalElements.Add(totalElements, blockOffset)
-
-	// Take min(start + blockOffset + maxBatchSize, totalElements).
-	end := new(big.Int).Add(start, maxBatchSize)
-	if totalElements.Cmp(end) < 0 {
-		end.Set(totalElements)
-	}
+	end.Add(end, blockOffset)
 
 	if start.Cmp(end) > 0 {
 		return nil, nil, fmt.Errorf("invalid range, "+
@@ -123,36 +150,43 @@ func (d *Driver) GetBatchBlockRange(
 	return start, end, nil
 }
 
-// SubmitBatchTx transforms the L2 blocks between start and end into a batch
-// transaction using the given nonce and gasPrice. The final transaction is
-// published and returned to the call.
-func (d *Driver) SubmitBatchTx(
+// CraftBatchTx transforms the L2 blocks between start and end into a batch
+// transaction using the given nonce. A dummy gas price is used in the resulting
+// transaction to use for size estimation.
+//
+// NOTE: This method SHOULD NOT publish the resulting transaction.
+func (d *Driver) CraftBatchTx(
 	ctx context.Context,
-	start, end, nonce, gasPrice *big.Int) (*types.Transaction, error) {
+	start, end, nonce *big.Int,
+) (*types.Transaction, error) {
+
+	name := d.cfg.Name
 
-	batchTxBuildStart := time.Now()
+	log.Info(name+" crafting batch tx", "start", start, "end", end,
+		"nonce", nonce)
 
-	var blocks []*l2types.Block
+	var (
+		stateRoots         [][stateRootSize]byte
+		totalStateRootSize uint64
+	)
 	for i := new(big.Int).Set(start); i.Cmp(end) < 0; i.Add(i, bigOne) {
+		// Consume state roots until reach our maximum tx size.
+		if totalStateRootSize+stateRootSize > d.cfg.MaxTxSize {
+			break
+		}
+
 		block, err := d.cfg.L2Client.BlockByNumber(ctx, i)
 		if err != nil {
 			return nil, err
 		}
 
-		blocks = append(blocks, block)
-
-		// TODO(conner): remove when moving to multiple blocks
-		break //nolint
-	}
-
-	var stateRoots = make([][32]byte, 0, len(blocks))
-	for _, block := range blocks {
+		totalStateRootSize += stateRootSize
 		stateRoots = append(stateRoots, block.Root())
 	}
 
-	batchTxBuildTime := float64(time.Since(batchTxBuildStart) / time.Millisecond)
-	d.metrics.BatchTxBuildTime.Set(batchTxBuildTime)
-	d.metrics.NumTxPerBatch.Observe(float64(len(blocks)))
+	d.metrics.NumElementsPerBatch().Observe(float64(len(stateRoots)))
+
+	log.Info(name+" batch constructed", "num_state_roots", len(stateRoots))
 
 	opts, err := bind.NewKeyedTransactorWithChainID(
 		d.cfg.PrivKey, d.cfg.ChainID,
@@ -160,12 +194,85 @@ func (d *Driver) SubmitBatchTx(
 	if err != nil {
 		return nil, err
 	}
-	opts.Nonce = nonce
 	opts.Context = ctx
-	opts.GasPrice = gasPrice
+	opts.Nonce = nonce
+	opts.NoSend = true
 
 	blockOffset := new(big.Int).SetUint64(d.cfg.BlockOffset)
 	offsetStartsAtIndex := new(big.Int).Sub(start, blockOffset)
 
-	return d.sccContract.AppendStateBatch(opts, stateRoots, offsetStartsAtIndex)
+	tx, err := d.sccContract.AppendStateBatch(
+		opts, stateRoots, offsetStartsAtIndex,
+	)
+	switch {
+	case err == nil:
+		return tx, nil
+
+	// If the transaction failed because the backend does not support
+	// eth_maxPriorityFeePerGas, fallback to using the default constant.
+	// Currently Alchemy is the only backend provider that exposes this method,
+	// so in the event their API is unreachable we can fallback to a degraded
+	// mode of operation. This also applies to our test environments, as hardhat
+	// doesn't support the query either.
+	case drivers.IsMaxPriorityFeePerGasNotFoundError(err):
+		log.Warn(d.cfg.Name + " eth_maxPriorityFeePerGas is unsupported " +
+			"by current backend, using fallback gasTipCap")
+		opts.GasTipCap = drivers.FallbackGasTipCap
+		return d.sccContract.AppendStateBatch(
+			opts, stateRoots, offsetStartsAtIndex,
+		)
+
+	default:
+		return nil, err
+	}
+}
+
+// UpdateGasPrice signs an otherwise identical txn to the one provided but with
+// updated gas prices sampled from the existing network conditions.
+//
+// NOTE: Thie method SHOULD NOT publish the resulting transaction.
+func (d *Driver) UpdateGasPrice(
+	ctx context.Context,
+	tx *types.Transaction,
+) (*types.Transaction, error) {
+
+	opts, err := bind.NewKeyedTransactorWithChainID(
+		d.cfg.PrivKey, d.cfg.ChainID,
+	)
+	if err != nil {
+		return nil, err
+	}
+	opts.Context = ctx
+	opts.Nonce = new(big.Int).SetUint64(tx.Nonce())
+	opts.NoSend = true
+
+	finalTx, err := d.rawSccContract.RawTransact(opts, tx.Data())
+	switch {
+	case err == nil:
+		return finalTx, nil
+
+	// If the transaction failed because the backend does not support
+	// eth_maxPriorityFeePerGas, fallback to using the default constant.
+	// Currently Alchemy is the only backend provider that exposes this method,
+	// so in the event their API is unreachable we can fallback to a degraded
+	// mode of operation. This also applies to our test environments, as hardhat
+	// doesn't support the query either.
+	case drivers.IsMaxPriorityFeePerGasNotFoundError(err):
+		log.Warn(d.cfg.Name + " eth_maxPriorityFeePerGas is unsupported " +
+			"by current backend, using fallback gasTipCap")
+		opts.GasTipCap = drivers.FallbackGasTipCap
+		return d.rawSccContract.RawTransact(opts, tx.Data())
+
+	default:
+		return nil, err
+	}
+}
+
+// SendTransaction injects a signed transaction into the pending pool for
+// execution.
+func (d *Driver) SendTransaction(
+	ctx context.Context,
+	tx *types.Transaction,
+) error {
+	return d.cfg.L1Client.SendTransaction(ctx, tx)
 }

go/batch-submitter/drivers/sequencer/batch.go

@@ -27,7 +27,7 @@ type BatchElement struct {
 	// Tx is the optional transaction that was applied in this batch.
 	//
 	// NOTE: This field will only be populated for sequencer txs.
-	Tx *l2types.Transaction
+	Tx *CachedTx
 }
 
 // IsSequencerTx returns true if this batch contains a tx that needs to be
@@ -54,14 +54,15 @@ func BatchElementFromBlock(block *l2types.Block) BatchElement {
 	isSequencerTx := tx.QueueOrigin() == l2types.QueueOriginSequencer
 
 	// Only include sequencer txs in the returned BatchElement.
-	if !isSequencerTx {
-		tx = nil
+	var cachedTx *CachedTx
+	if isSequencerTx {
+		cachedTx = NewCachedTx(tx)
 	}
 
 	return BatchElement{
 		Timestamp:   block.Time(),
 		BlockNumber: l1BlockNumber,
-		Tx:          tx,
+		Tx:          cachedTx,
 	}
 }
 
@@ -77,12 +78,13 @@ func GenSequencerBatchParams(
 	shouldStartAtElement uint64,
 	blockOffset uint64,
 	batch []BatchElement,
+	batchType BatchType,
 ) (*AppendSequencerBatchParams, error) {
 
 	var (
 		contexts               []BatchContext
 		groupedBlocks          []groupedBlock
-		txs                    []*l2types.Transaction
+		txs                    []*CachedTx
 		lastBlockIsSequencerTx bool
 		lastTimestamp          uint64
 		lastBlockNumber        uint64
@@ -90,11 +92,10 @@ func GenSequencerBatchParams(
 
 	// Iterate over the batch elements, grouping the elements according to
 	// the following critera:
-	//  - All sequencer txs in the same group must have the same timestamp
-	//     and block number.
+	//  - All txs in the same group must have the same timestamp.
+	//  - All sequencer txs in the same group must have the same block number.
 	//  - If sequencer txs exist in a group, they must come before all
 	//     queued txs.
-	//  - A group should never split consecutive queued txs.
 	//
 	// Assuming the block and timestamp criteria for sequencer txs are
 	// respected within each group, the following are examples of groupings:
@@ -109,17 +110,18 @@ func GenSequencerBatchParams(
 		// To enforce the above groupings, the following condition is
 		// used to determine when to create a new batch:
 		//  - On the first pass, or
-		//  - Whenever a sequecer tx is observed, and:
+		//  - The preceding tx has a different timestamp, or
+		//  - Whenever a sequencer tx is observed, and:
 		//    - The preceding tx was a queued tx, or
-		//    - The preceding sequencer tx has a different
-		//       block number/timestamp.
-		// Note that a sequencer tx is required to create a new group,
-		// so a queued tx may ONLY exist as the first element in a group
-		// if it is the very first element.
+		//    - The preceding sequencer tx has a different block number.
+		// Note that a sequencer tx is usually required to create a new group,
+		// so a queued tx may ONLY exist as the first element in a group if it
+		// is the very first element or it has a different timestamp from the
+		// preceding tx.
 		needsNewGroupOnSequencerTx := !lastBlockIsSequencerTx ||
-			el.Timestamp != lastTimestamp ||
 			el.BlockNumber != lastBlockNumber
 		if len(groupedBlocks) == 0 ||
+			el.Timestamp != lastTimestamp ||
 			(el.IsSequencerTx() && needsNewGroupOnSequencerTx) {
 
 			groupedBlocks = append(groupedBlocks, groupedBlock{})
@@ -187,5 +189,6 @@ func GenSequencerBatchParams(
 		TotalElementsToAppend: uint64(len(batch)),
 		Contexts:              contexts,
 		Txs:                   txs,
+		Type:                  batchType,
 	}, nil
 }

go/batch-submitter/drivers/sequencer/batch_test.go

@@ -31,7 +31,7 @@ func TestBatchElementFromBlock(t *testing.T) {
 	require.Equal(t, element.Timestamp, expTime)
 	require.Equal(t, element.BlockNumber, expBlockNumber)
 	require.True(t, element.IsSequencerTx())
-	require.Equal(t, element.Tx, expTx)
+	require.Equal(t, element.Tx.Tx(), expTx)
 
 	queueMeta := l2types.NewTransactionMeta(
 		new(big.Int).SetUint64(expBlockNumber), 0, nil,

go/batch-submitter/drivers/sequencer/cached_tx.go

+package sequencer
+
+import (
+	"bytes"
+	"fmt"
+
+	l2types "github.com/ethereum-optimism/optimism/l2geth/core/types"
+)
+
+type CachedTx struct {
+	tx    *l2types.Transaction
+	rawTx []byte
+}
+
+func NewCachedTx(tx *l2types.Transaction) *CachedTx {
+	var txBuf bytes.Buffer
+	if err := tx.EncodeRLP(&txBuf); err != nil {
+		panic(fmt.Sprintf("Unable to encode tx: %v", err))
+	}
+
+	return &CachedTx{
+		tx:    tx,
+		rawTx: txBuf.Bytes(),
+	}
+}
+
+func (t *CachedTx) Tx() *l2types.Transaction {
+	return t.tx
+}
+
+func (t *CachedTx) Size() int {
+	return len(t.rawTx)
+}
+
+func (t *CachedTx) RawTx() []byte {
+	return t.rawTx
+}

go/batch-submitter/drivers/sequencer/driver.go

@@ -3,15 +3,14 @@ package sequencer
 import (
 	"context"
 	"crypto/ecdsa"
-	"encoding/hex"
 	"fmt"
 	"math/big"
 	"strings"
-	"time"
 
 	"github.com/ethereum-optimism/optimism/go/batch-submitter/bindings/ctc"
-	"github.com/ethereum-optimism/optimism/go/batch-submitter/metrics"
-	l2types "github.com/ethereum-optimism/optimism/l2geth/core/types"
+	"github.com/ethereum-optimism/optimism/go/bss-core/drivers"
+	"github.com/ethereum-optimism/optimism/go/bss-core/metrics"
+	"github.com/ethereum-optimism/optimism/go/bss-core/txmgr"
 	l2ethclient "github.com/ethereum-optimism/optimism/l2geth/ethclient"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -37,6 +36,7 @@ type Config struct {
 	CTCAddr     common.Address
 	ChainID     *big.Int
 	PrivKey     *ecdsa.PrivateKey
+	BatchType   BatchType
 }
 
 type Driver struct {
@@ -45,7 +45,7 @@ type Driver struct {
 	rawCtcContract *bind.BoundContract
 	walletAddr     common.Address
 	ctcABI         *abi.ABI
-	metrics        *metrics.Metrics
+	metrics        *Metrics
 }
 
 func NewDriver(cfg Config) (*Driver, error) {
@@ -81,7 +81,7 @@ func NewDriver(cfg Config) (*Driver, error) {
 		rawCtcContract: rawCtcContract,
 		walletAddr:     walletAddr,
 		ctcABI:         ctcABI,
-		metrics:        metrics.NewMetrics(cfg.Name),
+		metrics:        NewMetrics(cfg.Name),
 	}, nil
 }
 
@@ -96,10 +96,25 @@ func (d *Driver) WalletAddr() common.Address {
 }
 
 // Metrics returns the subservice telemetry object.
-func (d *Driver) Metrics() *metrics.Metrics {
+func (d *Driver) Metrics() metrics.Metrics {
 	return d.metrics
 }
 
+// ClearPendingTx a publishes a transaction at the next available nonce in order
+// to clear any transactions in the mempool left over from a prior running
+// instance of the batch submitter.
+func (d *Driver) ClearPendingTx(
+	ctx context.Context,
+	txMgr txmgr.TxManager,
+	l1Client *ethclient.Client,
+) error {
+
+	return drivers.ClearPendingTx(
+		d.cfg.Name, ctx, txMgr, l1Client, d.walletAddr, d.cfg.PrivKey,
+		d.cfg.ChainID,
+	)
+}
+
 // GetBatchBlockRange returns the start and end L2 block heights that need to be
 // processed. Note that the end value is *exclusive*, therefore if the returned
 // values are identical nothing needs to be processed.
@@ -133,66 +148,124 @@ func (d *Driver) GetBatchBlockRange(
 	return start, end, nil
 }
 
-// SubmitBatchTx transforms the L2 blocks between start and end into a batch
-// transaction using the given nonce and gasPrice. The final transaction is
-// published and returned to the call.
-func (d *Driver) SubmitBatchTx(
+// CraftBatchTx transforms the L2 blocks between start and end into a batch
+// transaction using the given nonce. A dummy gas price is used in the resulting
+// transaction to use for size estimation.
+//
+// NOTE: This method SHOULD NOT publish the resulting transaction.
+func (d *Driver) CraftBatchTx(
 	ctx context.Context,
-	start, end, nonce, gasPrice *big.Int) (*types.Transaction, error) {
+	start, end, nonce *big.Int,
+) (*types.Transaction, error) {
 
 	name := d.cfg.Name
 
-	log.Info(name+" submitting batch tx", "start", start, "end", end,
-		"gasPrice", gasPrice)
+	log.Info(name+" crafting batch tx", "start", start, "end", end,
+		"nonce", nonce, "type", d.cfg.BatchType.String())
 
-	batchTxBuildStart := time.Now()
-
-	var blocks []*l2types.Block
+	var (
+		batchElements []BatchElement
+		totalTxSize   uint64
+	)
 	for i := new(big.Int).Set(start); i.Cmp(end) < 0; i.Add(i, bigOne) {
 		block, err := d.cfg.L2Client.BlockByNumber(ctx, i)
 		if err != nil {
 			return nil, err
 		}
 
-		blocks = append(blocks, block)
-
-		// TODO(conner): remove when moving to multiple blocks
-		break //nolint
-	}
+		// For each sequencer transaction, update our running total with the
+		// size of the transaction.
+		batchElement := BatchElementFromBlock(block)
+		if batchElement.IsSequencerTx() {
+			// Abort once the total size estimate is greater than the maximum
+			// configured size. This is a conservative estimate, as the total
+			// calldata size will be greater when batch contexts are included.
+			// Below this set will be further whittled until the raw call data
+			// size also adheres to this constraint.
+			txLen := batchElement.Tx.Size()
+			if totalTxSize+uint64(TxLenSize+txLen) > d.cfg.MaxTxSize {
+				break
+			}
+			totalTxSize += uint64(TxLenSize + txLen)
+		}
 
-	var batchElements = make([]BatchElement, 0, len(blocks))
-	for _, block := range blocks {
-		batchElements = append(batchElements, BatchElementFromBlock(block))
+		batchElements = append(batchElements, batchElement)
 	}
 
 	shouldStartAt := start.Uint64()
-	batchParams, err := GenSequencerBatchParams(
-		shouldStartAt, d.cfg.BlockOffset, batchElements,
-	)
-	if err != nil {
-		return nil, err
-	}
+	var pruneCount int
+	for {
+		batchParams, err := GenSequencerBatchParams(
+			shouldStartAt, d.cfg.BlockOffset, batchElements, d.cfg.BatchType,
+		)
+		if err != nil {
+			return nil, err
+		}
 
-	log.Info(name+" batch params", "params", fmt.Sprintf("%#v", batchParams))
+		batchArguments, err := batchParams.Serialize()
+		if err != nil {
+			return nil, err
+		}
 
-	batchArguments, err := batchParams.Serialize()
-	if err != nil {
-		return nil, err
-	}
+		appendSequencerBatchID := d.ctcABI.Methods[appendSequencerBatchMethodName].ID
+		batchCallData := append(appendSequencerBatchID, batchArguments...)
+
+		// Continue pruning until calldata size is less than configured max.
+		if uint64(len(batchCallData)) > d.cfg.MaxTxSize {
+			oldLen := len(batchElements)
+			newBatchElementsLen := (oldLen * 9) / 10
+			batchElements = batchElements[:newBatchElementsLen]
+			log.Info(name+" pruned batch", "old_num_txs", oldLen, "new_num_txs", newBatchElementsLen)
+			pruneCount++
+			continue
+		}
 
-	appendSequencerBatchID := d.ctcABI.Methods[appendSequencerBatchMethodName].ID
-	batchCallData := append(appendSequencerBatchID, batchArguments...)
+		d.metrics.NumElementsPerBatch().Observe(float64(len(batchElements)))
+		d.metrics.BatchPruneCount.Set(float64(pruneCount))
 
-	if uint64(len(batchCallData)) > d.cfg.MaxTxSize {
-		panic("call data too large")
-	}
+		log.Info(name+" batch constructed", "num_txs", len(batchElements), "length", len(batchCallData))
 
-	// Record the batch_tx_build_time.
-	batchTxBuildTime := float64(time.Since(batchTxBuildStart) / time.Millisecond)
-	d.metrics.BatchTxBuildTime.Set(batchTxBuildTime)
-	d.metrics.NumTxPerBatch.Observe(float64(len(blocks)))
+		opts, err := bind.NewKeyedTransactorWithChainID(
+			d.cfg.PrivKey, d.cfg.ChainID,
+		)
+		if err != nil {
+			return nil, err
+		}
+		opts.Context = ctx
+		opts.Nonce = nonce
+		opts.NoSend = true
+
+		tx, err := d.rawCtcContract.RawTransact(opts, batchCallData)
+		switch {
+		case err == nil:
+			return tx, nil
+
+		// If the transaction failed because the backend does not support
+		// eth_maxPriorityFeePerGas, fallback to using the default constant.
+		// Currently Alchemy is the only backend provider that exposes this
+		// method, so in the event their API is unreachable we can fallback to a
+		// degraded mode of operation. This also applies to our test
+		// environments, as hardhat doesn't support the query either.
+		case drivers.IsMaxPriorityFeePerGasNotFoundError(err):
+			log.Warn(d.cfg.Name + " eth_maxPriorityFeePerGas is unsupported " +
+				"by current backend, using fallback gasTipCap")
+			opts.GasTipCap = drivers.FallbackGasTipCap
+			return d.rawCtcContract.RawTransact(opts, batchCallData)
+
+		default:
+			return nil, err
+		}
+	}
+}
 
-	log.Info(name+" batch call data", "data", hex.EncodeToString(batchCallData))
+// UpdateGasPrice signs an otherwise identical txn to the one provided but with
+// updated gas prices sampled from the existing network conditions.
+//
+// NOTE: Thie method SHOULD NOT publish the resulting transaction.
+func (d *Driver) UpdateGasPrice(
+	ctx context.Context,
+	tx *types.Transaction,
+) (*types.Transaction, error) {
 
 	opts, err := bind.NewKeyedTransactorWithChainID(
 		d.cfg.PrivKey, d.cfg.ChainID,
@@ -200,9 +273,37 @@ func (d *Driver) SubmitBatchTx(
 	if err != nil {
 		return nil, err
 	}
-	opts.Nonce = nonce
 	opts.Context = ctx
-	opts.GasPrice = gasPrice
+	opts.Nonce = new(big.Int).SetUint64(tx.Nonce())
+	opts.NoSend = true
+
+	finalTx, err := d.rawCtcContract.RawTransact(opts, tx.Data())
+	switch {
+	case err == nil:
+		return finalTx, nil
+
+	// If the transaction failed because the backend does not support
+	// eth_maxPriorityFeePerGas, fallback to using the default constant.
+	// Currently Alchemy is the only backend provider that exposes this method,
+	// so in the event their API is unreachable we can fallback to a degraded
+	// mode of operation. This also applies to our test environments, as hardhat
+	// doesn't support the query either.
+	case drivers.IsMaxPriorityFeePerGasNotFoundError(err):
+		log.Warn(d.cfg.Name + " eth_maxPriorityFeePerGas is unsupported " +
+			"by current backend, using fallback gasTipCap")
+		opts.GasTipCap = drivers.FallbackGasTipCap
+		return d.rawCtcContract.RawTransact(opts, tx.Data())
+
+	default:
+		return nil, err
+	}
+}
 
-	return d.rawCtcContract.RawTransact(opts, batchCallData)
+// SendTransaction injects a signed transaction into the pending pool for
+// execution.
+func (d *Driver) SendTransaction(
+	ctx context.Context,
+	tx *types.Transaction,
+) error {
+	return d.cfg.L1Client.SendTransaction(ctx, tx)
 }

go/batch-submitter/drivers/sequencer/encoding.go

 package sequencer
 
 import (
+	"bufio"
 	"bytes"
+	"compress/zlib"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"io"
 	"math"
@@ -11,7 +14,19 @@ import (
 	l2rlp "github.com/ethereum-optimism/optimism/l2geth/rlp"
 )
 
-var byteOrder = binary.BigEndian
+const (
+	// TxLenSize is the number of bytes used to represent the size of a
+	// serialized sequencer transaction.
+	TxLenSize = 3
+)
+
+var (
+	// byteOrder represents the endiannes used for batch serialization
+	byteOrder = binary.BigEndian
+	// ErrMalformedBatch represents a batch that is not well formed
+	// according to the protocol specification
+	ErrMalformedBatch = errors.New("malformed batch")
+)
 
 // BatchContext denotes a range of transactions that belong the same batch. It
 // is used to compress shared fields that would otherwise be repeated for each
@@ -38,11 +53,14 @@ type BatchContext struct {
 //  - num_subsequent_queue_txs: 3 bytes
 //  - timestamp:                5 bytes
 //  - block_number:             5 bytes
+//
+// Note that writing to a bytes.Buffer cannot
+// error, so errors are ignored here
 func (c *BatchContext) Write(w *bytes.Buffer) {
-	writeUint64(w, c.NumSequencedTxs, 3)
-	writeUint64(w, c.NumSubsequentQueueTxs, 3)
-	writeUint64(w, c.Timestamp, 5)
-	writeUint64(w, c.BlockNumber, 5)
+	_ = writeUint64(w, c.NumSequencedTxs, 3)
+	_ = writeUint64(w, c.NumSubsequentQueueTxs, 3)
+	_ = writeUint64(w, c.Timestamp, 5)
+	_ = writeUint64(w, c.BlockNumber, 5)
 }
 
 // Read decodes the BatchContext from the passed reader. If fewer than 16-bytes
@@ -65,6 +83,45 @@ func (c *BatchContext) Read(r io.Reader) error {
 	return readUint64(r, &c.BlockNumber, 5)
 }
 
+// BatchType represents the type of batch being
+// submitted. When the first context in the batch
+// has a timestamp of 0, the blocknumber is interpreted
+// as an enum that represets the type
+type BatchType int8
+
+// Implements the Stringer interface for BatchType
+func (b BatchType) String() string {
+	switch b {
+	case BatchTypeLegacy:
+		return "LEGACY"
+	case BatchTypeZlib:
+		return "ZLIB"
+	default:
+		return ""
+	}
+}
+
+// BatchTypeFromString returns the BatchType
+// enum based on a human readable string
+func BatchTypeFromString(s string) BatchType {
+	switch s {
+	case "zlib", "ZLIB":
+		return BatchTypeZlib
+	case "legacy", "LEGACY":
+		return BatchTypeLegacy
+	default:
+		return BatchTypeLegacy
+	}
+}
+
+const (
+	// BatchTypeLegacy represets the legacy batch type
+	BatchTypeLegacy BatchType = -1
+	// BatchTypeZlib represents a batch type where the
+	// transaction data is compressed using zlib
+	BatchTypeZlib BatchType = 0
+)
+
 // AppendSequencerBatchParams holds the raw data required to submit a batch of
 // L2 txs to L1 CTC contract. Rather than encoding the objects using the
 // standard ABI encoding, a custom encoding is and provided in the call data to
@@ -88,7 +145,10 @@ type AppendSequencerBatchParams struct {
 
 	// Txs contains all sequencer txs that will be recorded in the L1 CTC
 	// contract.
-	Txs []*l2types.Transaction
+	Txs []*CachedTx
+
+	// The type of the batch
+	Type BatchType
 }
 
 // Write encodes the AppendSequencerBatchParams using the following format:
@@ -99,27 +159,73 @@ type AppendSequencerBatchParams struct {
 //  - [num txs ommitted]
 //    - tx_len:                       3 bytes
 //    - tx_bytes:                     tx_len bytes
+//
+// Typed batches include a dummy context as the first context
+// where the timestamp is 0. The blocknumber is interpreted
+// as an enum that defines the type. It is impossible to have
+// a timestamp of 0 in practice, so this safely can indicate
+// that the batch is typed.
+// Type 0 batches have a dummy context where the blocknumber is
+// set to 0. The transaction data is compressed with zlib before
+// submitting the transaction to the chain. The fields should_start_at_element,
+// total_elements_to_append, num_contexts and the contexts themselves
+// are not altered.
+//
+// Note that writing to a bytes.Buffer cannot
+// error, so errors are ignored here
 func (p *AppendSequencerBatchParams) Write(w *bytes.Buffer) error {
-	writeUint64(w, p.ShouldStartAtElement, 5)
-	writeUint64(w, p.TotalElementsToAppend, 3)
+	_ = writeUint64(w, p.ShouldStartAtElement, 5)
+	_ = writeUint64(w, p.TotalElementsToAppend, 3)
+
+	// There must be contexts if there are transactions
+	if len(p.Contexts) == 0 && len(p.Txs) != 0 {
+		return ErrMalformedBatch
+	}
+
+	// There must be transactions if there are contexts
+	if len(p.Txs) == 0 && len(p.Contexts) != 0 {
+		return ErrMalformedBatch
+	}
+
+	// copy the contexts as to not malleate the struct
+	// when it is a typed batch
+	contexts := make([]BatchContext, 0, len(p.Contexts)+1)
+	if p.Type == BatchTypeZlib {
+		// All zero values for the single batch context
+		// is desired here as blocknumber 0 means it is a zlib batch
+		contexts = append(contexts, BatchContext{})
+	}
+	contexts = append(contexts, p.Contexts...)
 
 	// Write number of contexts followed by each fixed-size BatchContext.
-	writeUint64(w, uint64(len(p.Contexts)), 3)
-	for _, context := range p.Contexts {
+	_ = writeUint64(w, uint64(len(contexts)), 3)
+	for _, context := range contexts {
 		context.Write(w)
 	}
 
-	// Write each length-prefixed tx.
-	var txBuf bytes.Buffer
-	for _, tx := range p.Txs {
-		txBuf.Reset()
-
-		if err := tx.EncodeRLP(&txBuf); err != nil {
+	switch p.Type {
+	case BatchTypeLegacy:
+		// Write each length-prefixed tx.
+		for _, tx := range p.Txs {
+			_ = writeUint64(w, uint64(tx.Size()), TxLenSize)
+			_, _ = w.Write(tx.RawTx()) // can't fail for bytes.Buffer
+		}
+	case BatchTypeZlib:
+		zw := zlib.NewWriter(w)
+		for _, tx := range p.Txs {
+			if err := writeUint64(zw, uint64(tx.Size()), TxLenSize); err != nil {
+				return err
+			}
+			if _, err := zw.Write(tx.RawTx()); err != nil {
+				return err
+			}
+		}
+		if err := zw.Close(); err != nil {
 			return err
 		}
 
-		writeUint64(w, uint64(txBuf.Len()), 3)
-		_, _ = w.Write(txBuf.Bytes()) // can't fail for bytes.Buffer
+	default:
+		return fmt.Errorf("Unknown batch type: %s", p.Type)
 	}
 
 	return nil
@@ -160,6 +266,8 @@ func (p *AppendSequencerBatchParams) Read(r io.Reader) error {
 		return err
 	}
 
+	// Ensure that contexts is never nil
+	p.Contexts = make([]BatchContext, 0)
 	for i := uint64(0); i < numContexts; i++ {
 		var batchContext BatchContext
 		if err := batchContext.Read(r); err != nil {
@@ -169,14 +277,44 @@ func (p *AppendSequencerBatchParams) Read(r io.Reader) error {
 		p.Contexts = append(p.Contexts, batchContext)
 	}
 
+	// Assume that it is a legacy batch at first
+	p.Type = BatchTypeLegacy
+
+	// Handle backwards compatible batch types
+	if len(p.Contexts) > 0 && p.Contexts[0].Timestamp == 0 {
+		switch p.Contexts[0].BlockNumber {
+		case 0:
+			// zlib compressed transaction data
+			p.Type = BatchTypeZlib
+			// remove the first dummy context
+			p.Contexts = p.Contexts[1:]
+			numContexts--
+
+			zr, err := zlib.NewReader(r)
+			if err != nil {
+				return err
+			}
+			defer zr.Close()
+
+			r = bufio.NewReader(zr)
+		}
+	}
+
 	// Deserialize any transactions. Since the number of txs is ommitted
 	// from the encoding, loop until the stream is consumed.
 	for {
 		var txLen uint64
-		err := readUint64(r, &txLen, 3)
+		err := readUint64(r, &txLen, TxLenSize)
 		// Getting an EOF when reading the txLen expected for a cleanly
-		// encoded object. Silece the error and return success.
+		// encoded object. Silence the error and return success if
+		// the batch is well formed.
 		if err == io.EOF {
+			if len(p.Contexts) == 0 && len(p.Txs) != 0 {
+				return ErrMalformedBatch
+			}
+			if len(p.Txs) == 0 && len(p.Contexts) != 0 {
+				return ErrMalformedBatch
+			}
 			return nil
 		} else if err != nil {
 			return err
@@ -187,12 +325,13 @@ func (p *AppendSequencerBatchParams) Read(r io.Reader) error {
 			return err
 		}
 
-		p.Txs = append(p.Txs, tx)
+		p.Txs = append(p.Txs, NewCachedTx(tx))
 	}
+
 }
 
 // writeUint64 writes a the bottom `n` bytes of `val` to `w`.
-func writeUint64(w *bytes.Buffer, val uint64, n uint) {
+func writeUint64(w io.Writer, val uint64, n uint) error {
 	if n < 1 || n > 8 {
 		panic(fmt.Sprintf("invalid number of bytes %d must be 1-8", n))
 	}
@@ -205,7 +344,8 @@ func writeUint64(w *bytes.Buffer, val uint64, n uint) {
 
 	var buf [8]byte
 	byteOrder.PutUint64(buf[:], val)
-	_, _ = w.Write(buf[8-n:]) // can't fail for bytes.Buffer
+	_, err := w.Write(buf[8-n:])
+	return err
 }
 
 // readUint64 reads `n` bytes from `r` and returns them in the lower `n` bytes

go/batch-submitter/drivers/sequencer/encoding_test.go

@@ -65,167 +65,21 @@ type AppendSequencerBatchParamsTest struct {
 	TotalElementsToAppend uint64                   `json:"total_elements_to_append"`
 	Contexts              []sequencer.BatchContext `json:"contexts"`
 	Txs                   []string                 `json:"txs"`
+	Error                 bool                     `json:"error"`
 }
 
-var appendSequencerBatchParamTests = AppendSequencerBatchParamsTestCases{
-	Tests: []AppendSequencerBatchParamsTest{
-		{
-			Name: "empty batch",
-			HexEncoding: "0000000000000000" +
-				"000000",
-			ShouldStartAtElement:  0,
-			TotalElementsToAppend: 0,
-			Contexts:              nil,
-			Txs:                   nil,
-		},
-		{
-			Name: "single tx",
-			HexEncoding: "0000000001000001" +
-				"000000" +
-				"00000ac9808080808080808080",
-			ShouldStartAtElement:  1,
-			TotalElementsToAppend: 1,
-			Contexts:              nil,
-			Txs: []string{
-				"c9808080808080808080",
-			},
-		},
-		{
-			Name: "multiple txs",
-			HexEncoding: "0000000001000004" +
-				"000000" +
-				"00000ac9808080808080808080" +
-				"00000ac9808080808080808080" +
-				"00000ac9808080808080808080" +
-				"00000ac9808080808080808080",
-			ShouldStartAtElement:  1,
-			TotalElementsToAppend: 4,
-			Contexts:              nil,
-			Txs: []string{
-				"c9808080808080808080",
-				"c9808080808080808080",
-				"c9808080808080808080",
-				"c9808080808080808080",
-			},
-		},
-		{
-			Name: "single context",
-			HexEncoding: "0000000001000000" +
-				"000001" +
-				"000102030405060708090a0b0c0d0e0f",
-			ShouldStartAtElement:  1,
-			TotalElementsToAppend: 0,
-			Contexts: []sequencer.BatchContext{
-				{
-					NumSequencedTxs:       0x000102,
-					NumSubsequentQueueTxs: 0x030405,
-					Timestamp:             0x060708090a,
-					BlockNumber:           0x0b0c0d0e0f,
-				},
-			},
-			Txs: nil,
-		},
-		{
-			Name: "multiple contexts",
-			HexEncoding: "0000000001000000" +
-				"000004" +
-				"000102030405060708090a0b0c0d0e0f" +
-				"000102030405060708090a0b0c0d0e0f" +
-				"000102030405060708090a0b0c0d0e0f" +
-				"000102030405060708090a0b0c0d0e0f",
-			ShouldStartAtElement:  1,
-			TotalElementsToAppend: 0,
-			Contexts: []sequencer.BatchContext{
-				{
-					NumSequencedTxs:       0x000102,
-					NumSubsequentQueueTxs: 0x030405,
-					Timestamp:             0x060708090a,
-					BlockNumber:           0x0b0c0d0e0f,
-				},
-				{
-					NumSequencedTxs:       0x000102,
-					NumSubsequentQueueTxs: 0x030405,
-					Timestamp:             0x060708090a,
-					BlockNumber:           0x0b0c0d0e0f,
-				},
-				{
-					NumSequencedTxs:       0x000102,
-					NumSubsequentQueueTxs: 0x030405,
-					Timestamp:             0x060708090a,
-					BlockNumber:           0x0b0c0d0e0f,
-				},
-				{
-					NumSequencedTxs:       0x000102,
-					NumSubsequentQueueTxs: 0x030405,
-					Timestamp:             0x060708090a,
-					BlockNumber:           0x0b0c0d0e0f,
-				},
-			},
-			Txs: nil,
-		},
-		{
-			Name: "complex",
-			HexEncoding: "0102030405060708" +
-				"000004" +
-				"000102030405060708090a0b0c0d0e0f" +
-				"000102030405060708090a0b0c0d0e0f" +
-				"000102030405060708090a0b0c0d0e0f" +
-				"000102030405060708090a0b0c0d0e0f" +
-				"00000ac9808080808080808080" +
-				"00000ac9808080808080808080" +
-				"00000ac9808080808080808080" +
-				"00000ac9808080808080808080",
-			ShouldStartAtElement:  0x0102030405,
-			TotalElementsToAppend: 0x060708,
-			Contexts: []sequencer.BatchContext{
-				{
-					NumSequencedTxs:       0x000102,
-					NumSubsequentQueueTxs: 0x030405,
-					Timestamp:             0x060708090a,
-					BlockNumber:           0x0b0c0d0e0f,
-				},
-				{
-					NumSequencedTxs:       0x000102,
-					NumSubsequentQueueTxs: 0x030405,
-					Timestamp:             0x060708090a,
-					BlockNumber:           0x0b0c0d0e0f,
-				},
-				{
-					NumSequencedTxs:       0x000102,
-					NumSubsequentQueueTxs: 0x030405,
-					Timestamp:             0x060708090a,
-					BlockNumber:           0x0b0c0d0e0f,
-				},
-				{
-					NumSequencedTxs:       0x000102,
-					NumSubsequentQueueTxs: 0x030405,
-					Timestamp:             0x060708090a,
-					BlockNumber:           0x0b0c0d0e0f,
-				},
-			},
-			Txs: []string{
-				"c9808080808080808080",
-				"c9808080808080808080",
-				"c9808080808080808080",
-				"c9808080808080808080",
-			},
-		},
-	},
-}
-
-// TestAppendSequencerBatchParamsEncodeDecodeMatchesJSON ensures that the
-// in-memory test vectors for valid encode/decode stay in sync with the JSON
-// version.
-func TestAppendSequencerBatchParamsEncodeDecodeMatchesJSON(t *testing.T) {
-	t.Parallel()
-
-	jsonBytes, err := json.MarshalIndent(appendSequencerBatchParamTests, "", "\t")
-	require.Nil(t, err)
+var appendSequencerBatchParamTests = AppendSequencerBatchParamsTestCases{}
 
+func init() {
 	data, err := os.ReadFile("./testdata/valid_append_sequencer_batch_params.json")
-	require.Nil(t, err)
+	if err != nil {
+		panic(err)
+	}
 
-	require.Equal(t, jsonBytes, data)
+	err = json.Unmarshal(data, &appendSequencerBatchParamTests)
+	if err != nil {
+		panic(err)
+	}
 }
 
 // TestAppendSequencerBatchParamsEncodeDecode asserts the proper encoding and
@@ -265,6 +119,7 @@ func testAppendSequencerBatchParamsEncodeDecode(
 		TotalElementsToAppend: test.TotalElementsToAppend,
 		Contexts:              test.Contexts,
 		Txs:                   nil,
+		Type:                  sequencer.BatchTypeLegacy,
 	}
 
 	// Decode the batch from the test string.
@@ -273,7 +128,12 @@ func testAppendSequencerBatchParamsEncodeDecode(
 
 	var params sequencer.AppendSequencerBatchParams
 	err = params.Read(bytes.NewReader(rawBytes))
-	require.Nil(t, err)
+	if test.Error {
+		require.ErrorIs(t, err, sequencer.ErrMalformedBatch)
+	} else {
+		require.Nil(t, err)
+	}
+	require.Equal(t, params.Type, sequencer.BatchTypeLegacy)
 
 	// Assert that the decoded params match the expected params. The
 	// transactions are compared serparetly (via hash), since the internal
@@ -290,16 +150,42 @@ func testAppendSequencerBatchParamsEncodeDecode(
 	// Finally, encode the decoded object and assert it matches the original
 	// hex string.
 	paramsBytes, err := params.Serialize()
+
+	// Return early when testing error cases, no need to reserialize again
+	if test.Error {
+		require.ErrorIs(t, err, sequencer.ErrMalformedBatch)
+		return
+	}
+
 	require.Nil(t, err)
 	require.Equal(t, test.HexEncoding, hex.EncodeToString(paramsBytes))
+
+	// Serialize the batches in compressed form
+	params.Type = sequencer.BatchTypeZlib
+	compressedParamsBytes, err := params.Serialize()
+	require.Nil(t, err)
+
+	// Deserialize the compressed batch
+	var paramsCompressed sequencer.AppendSequencerBatchParams
+	err = paramsCompressed.Read(bytes.NewReader(compressedParamsBytes))
+	require.Nil(t, err)
+	require.Equal(t, paramsCompressed.Type, sequencer.BatchTypeZlib)
+
+	expParams.Type = sequencer.BatchTypeZlib
+	decompressedTxs := paramsCompressed.Txs
+	paramsCompressed.Txs = nil
+
+	require.Equal(t, expParams, paramsCompressed)
+	compareTxs(t, expTxs, decompressedTxs)
+	paramsCompressed.Txs = decompressedTxs
 }
 
 // compareTxs compares a list of two transactions, testing each pair by tx hash.
 // This is used rather than require.Equal, since there `time` metadata on the
 // decoded tx and the expected tx will differ, and can't be modified/ignored.
-func compareTxs(t *testing.T, a, b []*l2types.Transaction) {
+func compareTxs(t *testing.T, a []*l2types.Transaction, b []*sequencer.CachedTx) {
 	require.Equal(t, len(a), len(b))
 	for i, txA := range a {
-		require.Equal(t, txA.Hash(), b[i].Hash())
+		require.Equal(t, txA.Hash(), b[i].Tx().Hash())
 	}
 }

go/batch-submitter/drivers/sequencer/metrics.go

+package sequencer
+
+import (
+	"github.com/ethereum-optimism/optimism/go/bss-core/metrics"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+// Metrics extends the BSS core metrics with additional metrics tracked by the
+// sequencer driver.
+type Metrics struct {
+	*metrics.Base
+
+	// BatchPruneCount tracks the number of times a batch of sequencer
+	// transactions is pruned in order to meet the desired size requirements.
+	BatchPruneCount prometheus.Gauge
+}
+
+// NewMetrics initializes a new, extended metrics object.
+func NewMetrics(subsystem string) *Metrics {
+	base := metrics.NewBase("batch_submitter", subsystem)
+	return &Metrics{
+		Base: base,
+		BatchPruneCount: promauto.NewGauge(prometheus.GaugeOpts{
+			Name:      "batch_prune_count",
+			Help:      "Number of times a batch is pruned",
+			Subsystem: base.SubsystemName(),
+		}),
+	}
+}

go/batch-submitter/flags/flags.go

@@ -80,6 +80,14 @@ var (
 		Required: true,
 		EnvVar:   prefixEnvVar("NUM_CONFIRMATIONS"),
 	}
+	SafeAbortNonceTooLowCountFlag = cli.Uint64Flag{
+		Name: "safe-abort-nonce-too-low-count",
+		Usage: "Number of ErrNonceTooLow observations required to " +
+			"give up on a tx at a particular nonce without receiving " +
+			"confirmation",
+		Required: true,
+		EnvVar:   prefixEnvVar("SAFE_ABORT_NONCE_TOO_LOW_COUNT"),
+	}
 	ResubmissionTimeoutFlag = cli.DurationFlag{
 		Name: "resubmission-timeout",
 		Usage: "Duration we will wait before resubmitting a " +
@@ -129,6 +137,13 @@ var (
 		Value:  "info",
 		EnvVar: prefixEnvVar("LOG_LEVEL"),
 	}
+	LogTerminalFlag = cli.BoolFlag{
+		Name: "log-terminal",
+		Usage: "If true, outputs logs in terminal format, otherwise prints " +
+			"in JSON format. If SENTRY_ENABLE is set to true, this flag is " +
+			"ignored and logs are printed using JSON",
+		EnvVar: prefixEnvVar("LOG_TERMINAL"),
+	}
 	SentryEnableFlag = cli.BoolFlag{
 		Name:   "sentry-enable",
 		Usage:  "Whether or not to enable Sentry. If true, sentry-dsn must also be set",
@@ -151,18 +166,6 @@ var (
 		Value:  1,
 		EnvVar: prefixEnvVar("BLOCK_OFFSET"),
 	}
-	MaxGasPriceInGweiFlag = cli.Uint64Flag{
-		Name:   "max-gas-price-in-gwei",
-		Usage:  "Maximum gas price the batch submitter can use for transactions",
-		Value:  100,
-		EnvVar: prefixEnvVar("MAX_GAS_PRICE_IN_GWEI"),
-	}
-	GasRetryIncrementFlag = cli.Uint64Flag{
-		Name:   "gas-retry-increment",
-		Usage:  "Default step by which to increment gas price bumps",
-		Value:  5,
-		EnvVar: prefixEnvVar("GAS_RETRY_INCREMENT_FLAG"),
-	}
 	SequencerPrivateKeyFlag = cli.StringFlag{
 		Name:   "sequencer-private-key",
 		Usage:  "The private key to use for sending to the sequencer contract",
@@ -191,6 +194,12 @@ var (
 			"mnemonic. The mnemonic flag must also be set.",
 		EnvVar: prefixEnvVar("PROPOSER_HD_PATH"),
 	}
+	SequencerBatchType = cli.StringFlag{
+		Name:   "sequencer-batch-type",
+		Usage:  "The type of sequencer batch to be submitted. Valid arguments are legacy or zlib.",
+		Value:  "legacy",
+		EnvVar: prefixEnvVar("SEQUENCER_BATCH_TYPE"),
+	}
 	MetricsServerEnableFlag = cli.BoolFlag{
 		Name:   "metrics-server-enable",
 		Usage:  "Whether or not to run the embedded metrics server",
@@ -208,6 +217,11 @@ var (
 		Value:  7300,
 		EnvVar: prefixEnvVar("METRICS_PORT"),
 	}
+	HTTP2DisableFlag = cli.BoolFlag{
+		Name:   "http2-disable",
+		Usage:  "Whether or not to disable HTTP/2 support.",
+		EnvVar: prefixEnvVar("HTTP2_DISABLE"),
+	}
 )
 
 var requiredFlags = []cli.Flag{
@@ -221,6 +235,7 @@ var requiredFlags = []cli.Flag{
 	MaxBatchSubmissionTimeFlag,
 	PollIntervalFlag,
 	NumConfirmationsFlag,
+	SafeAbortNonceTooLowCountFlag,
 	ResubmissionTimeoutFlag,
 	FinalityConfirmationsFlag,
 	RunTxBatchSubmitterFlag,
@@ -231,12 +246,12 @@ var requiredFlags = []cli.Flag{
 
 var optionalFlags = []cli.Flag{
 	LogLevelFlag,
+	LogTerminalFlag,
 	SentryEnableFlag,
 	SentryDsnFlag,
 	SentryTraceRateFlag,
 	BlockOffsetFlag,
-	MaxGasPriceInGweiFlag,
-	GasRetryIncrementFlag,
+	SequencerBatchType,
 	SequencerPrivateKeyFlag,
 	ProposerPrivateKeyFlag,
 	MnemonicFlag,
@@ -245,6 +260,7 @@ var optionalFlags = []cli.Flag{
 	MetricsServerEnableFlag,
 	MetricsHostnameFlag,
 	MetricsPortFlag,
+	HTTP2DisableFlag,
 }
 
 // Flags contains the list of configuration options available to the binary.

go/batch-submitter/go.mod

@@ -3,14 +3,15 @@ module github.com/ethereum-optimism/optimism/go/batch-submitter
 go 1.16
 
 require (
-	github.com/decred/dcrd/hdkeychain/v3 v3.0.0
+	github.com/ethereum-optimism/optimism/go/bss-core v0.0.0
 	github.com/ethereum-optimism/optimism/l2geth v1.0.0
-	github.com/ethereum/go-ethereum v1.10.12
+	github.com/ethereum/go-ethereum v1.10.16
 	github.com/getsentry/sentry-go v0.11.0
 	github.com/prometheus/client_golang v1.11.0
 	github.com/stretchr/testify v1.7.0
-	github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef
 	github.com/urfave/cli v1.22.5
 )
 
 replace github.com/ethereum-optimism/optimism/l2geth => ../../l2geth
+
+replace github.com/ethereum-optimism/optimism/go/bss-core => ../bss-core

go/batch-submitter/metrics/metrics.go

-package metrics
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-type Metrics struct {
-	// ETHBalance tracks the amount of ETH in the submitter's account.
-	ETHBalance prometheus.Gauge
-
-	// BatchSizeInBytes tracks the size of batch submission transactions.
-	BatchSizeInBytes prometheus.Histogram
-
-	// NumTxPerBatch tracks the number of L2 transactions in each batch
-	// submission.
-	NumTxPerBatch prometheus.Histogram
-
-	// SubmissionGasUsed tracks the amount of gas used to submit each batch.
-	SubmissionGasUsed prometheus.Histogram
-
-	// BatchsSubmitted tracks the total number of successful batch submissions.
-	BatchesSubmitted prometheus.Counter
-
-	// FailedSubmissions tracks the total number of failed batch submissions.
-	FailedSubmissions prometheus.Counter
-
-	// BatchTxBuildTime tracks the duration it takes to construct a batch
-	// transaction.
-	BatchTxBuildTime prometheus.Gauge
-
-	// BatchConfirmationTime tracks the duration it takes to confirm a batch
-	// transaction.
-	BatchConfirmationTime prometheus.Gauge
-}
-
-func NewMetrics(subsystem string) *Metrics {
-	return &Metrics{
-		ETHBalance: promauto.NewGauge(prometheus.GaugeOpts{
-			Name:      "batch_submitter_eth_balance",
-			Help:      "ETH balance of the batch submitter",
-			Subsystem: subsystem,
-		}),
-		BatchSizeInBytes: promauto.NewHistogram(prometheus.HistogramOpts{
-			Name:      "batch_submitter_batch_size_in_bytes",
-			Help:      "Size of batches in bytes",
-			Subsystem: subsystem,
-		}),
-		NumTxPerBatch: promauto.NewHistogram(prometheus.HistogramOpts{
-			Name:      "batch_submitter_num_txs_per_batch",
-			Help:      "Number of transaction in each batch",
-			Subsystem: subsystem,
-		}),
-		SubmissionGasUsed: promauto.NewHistogram(prometheus.HistogramOpts{
-			Name:      "batch_submitter_submission_gas_used",
-			Help:      "Gas used to submit each batch",
-			Subsystem: subsystem,
-		}),
-		BatchesSubmitted: promauto.NewCounter(prometheus.CounterOpts{
-			Name:      "batch_submitter_batches_submitted",
-			Help:      "Count of batches submitted",
-			Subsystem: subsystem,
-		}),
-		FailedSubmissions: promauto.NewCounter(prometheus.CounterOpts{
-			Name:      "batch_submitter_failed_submissions",
-			Help:      "Count of failed batch submissions",
-			Subsystem: subsystem,
-		}),
-		BatchTxBuildTime: promauto.NewGauge(prometheus.GaugeOpts{
-			Name:      "batch_submitter_batch_tx_build_time",
-			Help:      "Time to construct batch transactions",
-			Subsystem: subsystem,
-		}),
-		BatchConfirmationTime: promauto.NewGauge(prometheus.GaugeOpts{
-			Name:      "batch_submitter_batch_confirmation_time",
-			Help:      "Time to confirm batch transactions",
-			Subsystem: subsystem,
-		}),
-	}
-}

go/batch-submitter/package.json

 {
 	"name": "@eth-optimism/batch-submitter-service",
-	"version": "0.0.2",
+	"version": "0.1.5",
 	"private": true,
 	"devDependencies": {}
 }

go/bss-core/.gitignore

+/batch-submitter

go/bss-core/batch_submitter.go

+package bsscore
+
+import (
+	"context"
+)
+
+// BatchSubmitter is a service that configures the necessary resources for
+// running the TxBatchSubmitter and StateBatchSubmitter sub-services.
+type BatchSubmitter struct {
+	ctx      context.Context
+	services []*Service
+	cancel   func()
+}
+
+// NewBatchSubmitter initializes the BatchSubmitter, gathering any resources
+// that will be needed by the TxBatchSubmitter and StateBatchSubmitter
+// sub-services.
+func NewBatchSubmitter(
+	ctx context.Context,
+	cancel func(),
+	services []*Service,
+) (*BatchSubmitter, error) {
+
+	return &BatchSubmitter{
+		ctx:      ctx,
+		services: services,
+		cancel:   cancel,
+	}, nil
+}
+
+// Start starts all provided services.
+func (b *BatchSubmitter) Start() error {
+	for _, service := range b.services {
+		if err := service.Start(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Stop stops all provided services and blocks until shutdown.
+func (b *BatchSubmitter) Stop() {
+	b.cancel()
+	for _, service := range b.services {
+		_ = service.Stop()
+	}
+}

go/batch-submitter/crypto.go → go/bss-core/crypto.go

-package batchsubmitter
+package bsscore
 
 import (
 	"crypto/ecdsa"
@@ -10,6 +10,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/log"
 	"github.com/tyler-smith/go-bip39"
 )
 
@@ -106,3 +107,36 @@ func ParsePrivateKeyStr(privKeyStr string) (*ecdsa.PrivateKey, error) {
 	hex := strings.TrimPrefix(privKeyStr, "0x")
 	return crypto.HexToECDSA(hex)
 }
+
+// ParseWalletPrivKeyAndContractAddr returns the wallet private key to use for
+// sending transactions as well as the contract address to send to for a
+// particular sub-service.
+func ParseWalletPrivKeyAndContractAddr(
+	name string,
+	mnemonic string,
+	hdPath string,
+	privKeyStr string,
+	contractAddrStr string,
+) (*ecdsa.PrivateKey, common.Address, error) {
+
+	// Parse wallet private key from either privkey string or BIP39 mnemonic
+	// and BIP32 HD derivation path.
+	privKey, err := GetConfiguredPrivateKey(mnemonic, hdPath, privKeyStr)
+	if err != nil {
+		return nil, common.Address{}, err
+	}
+
+	// Parse the target contract address the wallet will send to.
+	contractAddress, err := ParseAddress(contractAddrStr)
+	if err != nil {
+		return nil, common.Address{}, err
+	}
+
+	// Log wallet address rather than private key...
+	walletAddress := crypto.PubkeyToAddress(privKey.PublicKey)
+
+	log.Info(name+" wallet params parsed successfully", "wallet_address",
+		walletAddress, "contract_address", contractAddress)
+
+	return privKey, contractAddress, nil
+}

go/batch-submitter/crypto_test.go → go/bss-core/crypto_test.go

-package batchsubmitter_test
+package bsscore_test
 
 import (
 	"bytes"
@@ -6,7 +6,7 @@ import (
 	"strings"
 	"testing"
 
-	batchsubmitter "github.com/ethereum-optimism/optimism/go/batch-submitter"
+	bsscore "github.com/ethereum-optimism/optimism/go/bss-core"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/stretchr/testify/require"
@@ -76,7 +76,7 @@ func TestParseAddress(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			addr, err := batchsubmitter.ParseAddress(test.addr)
+			addr, err := bsscore.ParseAddress(test.addr)
 			require.Equal(t, err, test.expErr)
 			if test.expErr != nil {
 				return
@@ -141,7 +141,7 @@ func TestDerivePrivateKey(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			privKey, err := batchsubmitter.DerivePrivateKey(test.mnemonic, test.hdPath)
+			privKey, err := bsscore.DerivePrivateKey(test.mnemonic, test.hdPath)
 			require.Equal(t, err, test.expErr)
 			if test.expErr != nil {
 				return
@@ -193,7 +193,7 @@ func TestParsePrivateKeyStr(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			privKey, err := batchsubmitter.ParsePrivateKeyStr(test.privKeyStr)
+			privKey, err := bsscore.ParsePrivateKeyStr(test.privKeyStr)
 			require.Equal(t, err, test.expErr)
 			if test.expErr != nil {
 				return
@@ -246,20 +246,20 @@ func TestGetConfiguredPrivateKey(t *testing.T) {
 			mnemonic:   validMnemonic,
 			hdPath:     validHDPath,
 			privKeyStr: validPrivKeyStr,
-			expErr:     batchsubmitter.ErrCannotGetPrivateKey,
+			expErr:     bsscore.ErrCannotGetPrivateKey,
 		},
 		{
 			name:       "neither menmonic+hdpath or privkey",
 			mnemonic:   "",
 			hdPath:     "",
 			privKeyStr: "",
-			expErr:     batchsubmitter.ErrCannotGetPrivateKey,
+			expErr:     bsscore.ErrCannotGetPrivateKey,
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			privKey, err := batchsubmitter.GetConfiguredPrivateKey(
+			privKey, err := bsscore.GetConfiguredPrivateKey(
 				test.mnemonic, test.hdPath, test.privKeyStr,
 			)
 			require.Equal(t, err, test.expErr)

go/bss-core/dial/common.go

+package dial
+
+import "time"
+
+const (
+	// DefaultTimeout is default duration the service will wait on startup to
+	// make a connection to either the L1 or L2 backends.
+	DefaultTimeout = 5 * time.Second
+)

go/bss-core/dial/l1_client.go

+package dial
+
+import (
+	"context"
+	"crypto/tls"
+	"net/http"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+// L1EthClientWithTimeout attempts to dial the L1 provider using the
+// provided URL. If the dial doesn't complete within DefaultTimeout seconds,
+// this method will return an error.
+func L1EthClientWithTimeout(ctx context.Context, url string, disableHTTP2 bool) (
+	*ethclient.Client, error) {
+
+	ctxt, cancel := context.WithTimeout(ctx, DefaultTimeout)
+	defer cancel()
+
+	if strings.HasPrefix(url, "http") {
+		httpClient := new(http.Client)
+		if disableHTTP2 {
+			log.Info("Disabled HTTP/2 support in L1 eth client")
+			httpClient.Transport = &http.Transport{
+				TLSNextProto: make(map[string]func(authority string, c *tls.Conn) http.RoundTripper),
+			}
+		}
+
+		rpcClient, err := rpc.DialHTTPWithClient(url, httpClient)
+		if err != nil {
+			return nil, err
+		}
+
+		return ethclient.NewClient(rpcClient), nil
+	}
+
+	return ethclient.DialContext(ctxt, url)
+}

go/bss-core/drivers/clear_pending_tx.go

+package drivers
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"errors"
+	"math/big"
+	"strings"
+
+	"github.com/ethereum-optimism/optimism/go/bss-core/txmgr"
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// ErrClearPendingRetry signals that a transaction from a previous running
+// instance confirmed rather than our clearing transaction on startup. In this
+// case the caller should retry.
+var ErrClearPendingRetry = errors.New("retry clear pending txn")
+
+// ClearPendingTx publishes a NOOP transaction at the wallet's next unused
+// nonce. This is used on restarts in order to clear the mempool of any prior
+// publications and ensure the batch submitter starts submitting from a clean
+// slate.
+func ClearPendingTx(
+	name string,
+	ctx context.Context,
+	txMgr txmgr.TxManager,
+	l1Client L1Client,
+	walletAddr common.Address,
+	privKey *ecdsa.PrivateKey,
+	chainID *big.Int,
+) error {
+
+	// Query for the submitter's current nonce.
+	nonce, err := l1Client.NonceAt(ctx, walletAddr, nil)
+	if err != nil {
+		log.Error(name+" unable to get current nonce",
+			"err", err)
+		return err
+	}
+
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	// Construct the clearing transaction submission clousure that will attempt
+	// to send the a clearing transaction transaction at the given nonce and gas
+	// price.
+	updateGasPrice := func(
+		ctx context.Context,
+	) (*types.Transaction, error) {
+		log.Info(name+" clearing pending tx", "nonce", nonce)
+
+		signedTx, err := SignClearingTx(
+			name, ctx, walletAddr, nonce, l1Client, privKey, chainID,
+		)
+		if err != nil {
+			log.Error(name+" unable to sign clearing tx", "nonce", nonce,
+				"err", err)
+			return nil, err
+		}
+
+		return signedTx, nil
+	}
+
+	sendTx := func(ctx context.Context, tx *types.Transaction) error {
+		txHash := tx.Hash()
+		gasTipCap := tx.GasTipCap()
+		gasFeeCap := tx.GasFeeCap()
+
+		err := l1Client.SendTransaction(ctx, tx)
+		switch {
+
+		// Clearing transaction successfully confirmed.
+		case err == nil:
+			log.Info(name+" submitted clearing tx", "nonce", nonce,
+				"gasTipCap", gasTipCap, "gasFeeCap", gasFeeCap,
+				"txHash", txHash)
+
+			return nil
+
+		// Getting a nonce too low error implies that a previous transaction in
+		// the mempool has confirmed and we should abort trying to publish at
+		// this nonce.
+		case strings.Contains(err.Error(), core.ErrNonceTooLow.Error()):
+			log.Info(name + " transaction from previous restart confirmed, " +
+				"aborting mempool clearing")
+			cancel()
+			return context.Canceled
+
+		// An unexpected error occurred. This also handles the case where the
+		// clearing transaction has not yet bested the gas price a prior
+		// transaction in the mempool at this nonce. In such a case we will
+		// continue until our ratchetting strategy overtakes the old
+		// transaction, or abort if the old one confirms.
+		default:
+			log.Error(name+" unable to submit clearing tx",
+				"nonce", nonce, "gasTipCap", gasTipCap, "gasFeeCap", gasFeeCap,
+				"txHash", txHash, "err", err)
+			return err
+		}
+	}
+
+	receipt, err := txMgr.Send(ctx, updateGasPrice, sendTx)
+	switch {
+
+	// If the current context is canceled, a prior transaction in the mempool
+	// confirmed. The caller should retry, which will use the next nonce, before
+	// proceeding.
+	case err == context.Canceled:
+		log.Info(name + " transaction from previous restart confirmed, " +
+			"proceeding to startup")
+		return ErrClearPendingRetry
+
+	// Otherwise we were unable to confirm our transaction, this method should
+	// be retried by the caller.
+	case err != nil:
+		log.Warn(name+" unable to send clearing tx", "nonce", nonce,
+			"err", err)
+		return err
+
+	// We succeeded in confirming a clearing transaction. Proceed to startup as
+	// normal.
+	default:
+		log.Info(name+" cleared pending tx", "nonce", nonce,
+			"txHash", receipt.TxHash)
+		return nil
+	}
+}
+
+// SignClearingTx creates a signed clearing tranaction which sends 0 ETH back to
+// the sender's address. EstimateGas is used to set an appropriate gas limit.
+func SignClearingTx(
+	name string,
+	ctx context.Context,
+	walletAddr common.Address,
+	nonce uint64,
+	l1Client L1Client,
+	privKey *ecdsa.PrivateKey,
+	chainID *big.Int,
+) (*types.Transaction, error) {
+
+	gasTipCap, err := l1Client.SuggestGasTipCap(ctx)
+	if err != nil {
+		if !IsMaxPriorityFeePerGasNotFoundError(err) {
+			return nil, err
+		}
+
+		// If the transaction failed because the backend does not support
+		// eth_maxPriorityFeePerGas, fallback to using the default constant.
+		// Currently Alchemy is the only backend provider that exposes this
+		// method, so in the event their API is unreachable we can fallback to a
+		// degraded mode of operation. This also applies to our test
+		// environments, as hardhat doesn't support the query either.
+		log.Warn(name + " eth_maxPriorityFeePerGas is unsupported " +
+			"by current backend, using fallback gasTipCap")
+		gasTipCap = FallbackGasTipCap
+	}
+
+	head, err := l1Client.HeaderByNumber(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	gasFeeCap := txmgr.CalcGasFeeCap(head.BaseFee, gasTipCap)
+
+	gasLimit, err := l1Client.EstimateGas(ctx, ethereum.CallMsg{
+		From:      walletAddr,
+		To:        &walletAddr,
+		GasFeeCap: gasFeeCap,
+		GasTipCap: gasTipCap,
+		Value:     nil,
+		Data:      nil,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	tx := CraftClearingTx(walletAddr, nonce, gasFeeCap, gasTipCap, gasLimit)
+
+	return types.SignTx(
+		tx, types.LatestSignerForChainID(chainID), privKey,
+	)
+}
+
+// CraftClearingTx creates an unsigned clearing transaction which sends 0 ETH
+// back to the sender's address.
+func CraftClearingTx(
+	walletAddr common.Address,
+	nonce uint64,
+	gasFeeCap *big.Int,
+	gasTipCap *big.Int,
+	gasLimit uint64,
+) *types.Transaction {
+
+	return types.NewTx(&types.DynamicFeeTx{
+		To:        &walletAddr,
+		Nonce:     nonce,
+		Gas:       gasLimit,
+		GasFeeCap: gasFeeCap,
+		GasTipCap: gasTipCap,
+		Value:     nil,
+		Data:      nil,
+	})
+}

go/bss-core/drivers/interface.go

+package drivers
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// L1Client is an abstraction over an L1 Ethereum client functionality required
+// by the batch submitter.
+type L1Client interface {
+	// EstimateGas tries to estimate the gas needed to execute a specific
+	// transaction based on the current pending state of the backend blockchain.
+	// There is no guarantee that this is the true gas limit requirement as
+	// other transactions may be added or removed by miners, but it should
+	// provide a basis for setting a reasonable default.
+	EstimateGas(context.Context, ethereum.CallMsg) (uint64, error)
+
+	// HeaderByNumber returns a block header from the current canonical chain.
+	// If number is nil, the latest known header is returned.
+	HeaderByNumber(context.Context, *big.Int) (*types.Header, error)
+
+	// NonceAt returns the account nonce of the given account. The block number
+	// can be nil, in which case the nonce is taken from the latest known block.
+	NonceAt(context.Context, common.Address, *big.Int) (uint64, error)
+
+	// SendTransaction injects a signed transaction into the pending pool for
+	// execution.
+	//
+	// If the transaction was a contract creation use the TransactionReceipt
+	// method to get the contract address after the transaction has been mined.
+	SendTransaction(context.Context, *types.Transaction) error
+
+	// SuggestGasTipCap retrieves the currently suggested gas tip cap after 1559
+	// to allow a timely execution of a transaction.
+	SuggestGasTipCap(context.Context) (*big.Int, error)
+
+	// TransactionReceipt returns the receipt of a transaction by transaction
+	// hash. Note that the receipt is not available for pending transactions.
+	TransactionReceipt(context.Context, common.Hash) (*types.Receipt, error)
+}

go/bss-core/drivers/max_priority_fee_fallback.go

+package drivers
+
+import (
+	"errors"
+	"math/big"
+	"strings"
+)
+
+var (
+	errMaxPriorityFeePerGasNotFound = errors.New(
+		"Method eth_maxPriorityFeePerGas not found",
+	)
+
+	// FallbackGasTipCap is the default fallback gasTipCap used when we are
+	// unable to query an L1 backend for a suggested gasTipCap.
+	FallbackGasTipCap = big.NewInt(1500000000)
+)
+
+// IsMaxPriorityFeePerGasNotFoundError returns true if the provided error
+// signals that the backend does not support the eth_maxPrirorityFeePerGas
+// method. In this case, the caller should fallback to using the constant above.
+func IsMaxPriorityFeePerGasNotFoundError(err error) bool {
+	return strings.Contains(
+		err.Error(), errMaxPriorityFeePerGasNotFound.Error(),
+	)
+}

go/bss-core/go.mod

+module github.com/ethereum-optimism/optimism/go/bss-core
+
+go 1.16
+
+require (
+	github.com/btcsuite/btcd v0.22.0-beta // indirect
+	github.com/decred/dcrd/hdkeychain/v3 v3.0.0
+	github.com/ethereum/go-ethereum v1.10.12
+	github.com/getsentry/sentry-go v0.11.0
+	github.com/prometheus/client_golang v1.11.0
+	github.com/stretchr/testify v1.7.0
+	github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef
+)

go/bss-core/metrics/interface.go

+package metrics
+
+import "github.com/prometheus/client_golang/prometheus"
+
+type Metrics interface {
+	// SubsystemName returns the subsystem name for the metrics group.
+	SubsystemName() string
+
+	// BalanceETH tracks the amount of ETH in the submitter's account.
+	BalanceETH() prometheus.Gauge
+
+	// BatchSizeBytes tracks the size of batch submission transactions.
+	BatchSizeBytes() prometheus.Summary
+
+	// NumElementsPerBatch tracks the number of L2 transactions in each batch
+	// submission.
+	NumElementsPerBatch() prometheus.Summary
+
+	// SubmissionTimestamp tracks the time at which each batch was confirmed.
+	SubmissionTimestamp() prometheus.Gauge
+
+	// SubmissionGasUsedWei tracks the amount of gas used to submit each batch.
+	SubmissionGasUsedWei() prometheus.Gauge
+
+	// BatchsSubmitted tracks the total number of successful batch submissions.
+	BatchesSubmitted() prometheus.Counter
+
+	// FailedSubmissions tracks the total number of failed batch submissions.
+	FailedSubmissions() prometheus.Counter
+
+	// BatchTxBuildTimeMs tracks the duration it takes to construct a batch
+	// transaction.
+	BatchTxBuildTimeMs() prometheus.Gauge
+
+	// BatchConfirmationTimeMs tracks the duration it takes to confirm a batch
+	// transaction.
+	BatchConfirmationTimeMs() prometheus.Gauge
+}

go/bss-core/metrics/metrics.go

+package metrics
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+type Base struct {
+	// subsystemName stores the name that will prefix all metrics. This can be
+	// used by drivers to futher extend the core metrics and ensure they use the
+	// same prefix.
+	subsystemName string
+
+	// balanceETH tracks the amount of ETH in the submitter's account.
+	balanceETH prometheus.Gauge
+
+	// batchSizeBytes tracks the size of batch submission transactions.
+	batchSizeBytes prometheus.Summary
+
+	// numElementsPerBatch tracks the number of L2 transactions in each batch
+	// submission.
+	numElementsPerBatch prometheus.Summary
+
+	// submissionTimestamp tracks the time at which each batch was confirmed.
+	submissionTimestamp prometheus.Gauge
+
+	// submissionGasUsedWei tracks the amount of gas used to submit each batch.
+	submissionGasUsedWei prometheus.Gauge
+
+	// batchsSubmitted tracks the total number of successful batch submissions.
+	batchesSubmitted prometheus.Counter
+
+	// failedSubmissions tracks the total number of failed batch submissions.
+	failedSubmissions prometheus.Counter
+
+	// batchTxBuildTimeMs tracks the duration it takes to construct a batch
+	// transaction.
+	batchTxBuildTimeMs prometheus.Gauge
+
+	// batchConfirmationTimeMs tracks the duration it takes to confirm a batch
+	// transaction.
+	batchConfirmationTimeMs prometheus.Gauge
+}
+
+func NewBase(serviceName, subServiceName string) *Base {
+	subsystem := MakeSubsystemName(serviceName, subServiceName)
+	return &Base{
+		subsystemName: subsystem,
+		balanceETH: promauto.NewGauge(prometheus.GaugeOpts{
+			Name:      "balance_eth",
+			Help:      "ETH balance of the batch submitter",
+			Subsystem: subsystem,
+		}),
+		batchSizeBytes: promauto.NewSummary(prometheus.SummaryOpts{
+			Name:       "batch_size_bytes",
+			Help:       "Size of batches in bytes",
+			Subsystem:  subsystem,
+			Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
+		}),
+		numElementsPerBatch: promauto.NewSummary(prometheus.SummaryOpts{
+			Name:       "num_elements_per_batch",
+			Help:       "Number of elements in each batch",
+			Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
+			Subsystem:  subsystem,
+		}),
+		submissionTimestamp: promauto.NewGauge(prometheus.GaugeOpts{
+			Name:      "submission_timestamp_ms",
+			Help:      "Timestamp of last batch submitter submission",
+			Subsystem: subsystem,
+		}),
+		submissionGasUsedWei: promauto.NewGauge(prometheus.GaugeOpts{
+			Name:      "submission_gas_used_wei",
+			Help:      "Gas used to submit each batch",
+			Subsystem: subsystem,
+		}),
+		batchesSubmitted: promauto.NewCounter(prometheus.CounterOpts{
+			Name:      "batches_submitted",
+			Help:      "Count of batches submitted",
+			Subsystem: subsystem,
+		}),
+		failedSubmissions: promauto.NewCounter(prometheus.CounterOpts{
+			Name:      "failed_submissions",
+			Help:      "Count of failed batch submissions",
+			Subsystem: subsystem,
+		}),
+		batchTxBuildTimeMs: promauto.NewGauge(prometheus.GaugeOpts{
+			Name:      "batch_tx_build_time_ms",
+			Help:      "Time to construct batch transactions",
+			Subsystem: subsystem,
+		}),
+		batchConfirmationTimeMs: promauto.NewGauge(prometheus.GaugeOpts{
+			Name:      "batch_confirmation_time_ms",
+			Help:      "Time to confirm batch transactions",
+			Subsystem: subsystem,
+		}),
+	}
+}
+
+// SubsystemName returns the subsystem name for the metrics group.
+func (b *Base) SubsystemName() string {
+	return b.subsystemName
+}
+
+// BalanceETH tracks the amount of ETH in the submitter's account.
+func (b *Base) BalanceETH() prometheus.Gauge {
+	return b.balanceETH
+}
+
+// BatchSizeBytes tracks the size of batch submission transactions.
+func (b *Base) BatchSizeBytes() prometheus.Summary {
+	return b.batchSizeBytes
+}
+
+// NumElementsPerBatch tracks the number of L2 transactions in each batch
+// submission.
+func (b *Base) NumElementsPerBatch() prometheus.Summary {
+	return b.numElementsPerBatch
+}
+
+// SubmissionTimestamp tracks the time at which each batch was confirmed.
+func (b *Base) SubmissionTimestamp() prometheus.Gauge {
+	return b.submissionTimestamp
+}
+
+// SubmissionGasUsedWei tracks the amount of gas used to submit each batch.
+func (b *Base) SubmissionGasUsedWei() prometheus.Gauge {
+	return b.submissionGasUsedWei
+}
+
+// BatchsSubmitted tracks the total number of successful batch submissions.
+func (b *Base) BatchesSubmitted() prometheus.Counter {
+	return b.batchesSubmitted
+}
+
+// FailedSubmissions tracks the total number of failed batch submissions.
+func (b *Base) FailedSubmissions() prometheus.Counter {
+	return b.failedSubmissions
+}
+
+// BatchTxBuildTimeMs tracks the duration it takes to construct a batch
+// transaction.
+func (b *Base) BatchTxBuildTimeMs() prometheus.Gauge {
+	return b.batchTxBuildTimeMs
+}
+
+// BatchConfirmationTimeMs tracks the duration it takes to confirm a batch
+// transaction.
+func (b *Base) BatchConfirmationTimeMs() prometheus.Gauge {
+	return b.batchConfirmationTimeMs
+}
+
+// MakeSubsystemName builds the subsystem name for a group of metrics, which
+// prometheus will use to prefix all metrics in the group. If two non-empty
+// strings are provided, they are joined with an underscore. If only one
+// non-empty string is provided, that name will be used alone. Otherwise an
+// empty string is returned after converting the characters to lower case.
+//
+// NOTE: This method panics if spaces are included in either string.
+func MakeSubsystemName(serviceName string, subServiceName string) string {
+	var subsystem string
+	switch {
+	case serviceName != "" && subServiceName != "":
+		subsystem = fmt.Sprintf("%s_%s", serviceName, subServiceName)
+	case serviceName != "":
+		subsystem = serviceName
+	default:
+		subsystem = subServiceName
+	}
+
+	if strings.ContainsAny(subsystem, " ") {
+		panic(fmt.Sprintf("metrics name \"%s\"cannot have spaces", subsystem))
+	}
+
+	return strings.ToLower(subsystem)
+}

go/bss-core/metrics/run_metrics_server.go

+package metrics
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+// RunServer spins up a prometheus metrics server at the provided hostname and
+// port.
+//
+// NOTE: This method MUST be run as a goroutine.
+func RunServer(hostname string, port uint64) {
+	metricsPortStr := strconv.FormatUint(port, 10)
+	metricsAddr := fmt.Sprintf("%s:%s", hostname, metricsPortStr)
+
+	http.Handle("/metrics", promhttp.Handler())
+	_ = http.ListenAndServe(metricsAddr, nil)
+}

go/bss-core/mock/l1client.go

+package mock
+
+import (
+	"context"
+	"math/big"
+	"sync"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// L1ClientConfig houses the internal methods that are executed by the mock
+// L1Client. Any members left as nil will panic on execution.
+type L1ClientConfig struct {
+	// BlockNumber returns the most recent block number.
+	BlockNumber func(context.Context) (uint64, error)
+
+	// EstimateGas tries to estimate the gas needed to execute a specific
+	// transaction based on the current pending state of the backend blockchain.
+	// There is no guarantee that this is the true gas limit requirement as
+	// other transactions may be added or removed by miners, but it should
+	// provide a basis for setting a reasonable default.
+	EstimateGas func(context.Context, ethereum.CallMsg) (uint64, error)
+
+	// HeaderByNumber returns a block header from the current canonical chain.
+	// If number is nil, the latest known header is returned.
+	HeaderByNumber func(context.Context, *big.Int) (*types.Header, error)
+
+	// NonceAt returns the account nonce of the given account. The block number
+	// can be nil, in which case the nonce is taken from the latest known block.
+	NonceAt func(context.Context, common.Address, *big.Int) (uint64, error)
+
+	// SendTransaction injects a signed transaction into the pending pool for
+	// execution.
+	//
+	// If the transaction was a contract creation use the TransactionReceipt
+	// method to get the contract address after the transaction has been mined.
+	SendTransaction func(context.Context, *types.Transaction) error
+
+	// SuggestGasTipCap retrieves the currently suggested gas tip cap after 1559
+	// to allow a timely execution of a transaction.
+	SuggestGasTipCap func(context.Context) (*big.Int, error)
+
+	// TransactionReceipt returns the receipt of a transaction by transaction
+	// hash. Note that the receipt is not available for pending transactions.
+	TransactionReceipt func(context.Context, common.Hash) (*types.Receipt, error)
+}
+
+// L1Client represents a mock L1Client.
+type L1Client struct {
+	cfg L1ClientConfig
+	mu  sync.RWMutex
+}
+
+// NewL1Client returns a new L1Client using the mocked methods in the
+// L1ClientConfig.
+func NewL1Client(cfg L1ClientConfig) *L1Client {
+	return &L1Client{
+		cfg: cfg,
+	}
+}
+
+// BlockNumber returns the most recent block number.
+func (c *L1Client) BlockNumber(ctx context.Context) (uint64, error) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	return c.cfg.BlockNumber(ctx)
+}
+
+// EstimateGas tries to estimate the gas needed to execute a specific
+// transaction based on the current pending state of the backend blockchain.
+// There is no guarantee that this is the true gas limit requirement as other
+// transactions may be added or removed by miners, but it should provide a basis
+// for setting a reasonable default.
+func (c *L1Client) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64, error) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	return c.cfg.EstimateGas(ctx, msg)
+}
+
+// HeaderByNumber returns a block header from the current canonical chain. If
+// number is nil, the latest known header is returned.
+func (c *L1Client) HeaderByNumber(ctx context.Context, blockNumber *big.Int) (*types.Header, error) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	return c.cfg.HeaderByNumber(ctx, blockNumber)
+}
+
+// NonceAt executes the mock NonceAt method.
+func (c *L1Client) NonceAt(ctx context.Context, addr common.Address, blockNumber *big.Int) (uint64, error) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	return c.cfg.NonceAt(ctx, addr, blockNumber)
+}
+
+// SendTransaction executes the mock SendTransaction method.
+func (c *L1Client) SendTransaction(ctx context.Context, tx *types.Transaction) error {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	return c.cfg.SendTransaction(ctx, tx)
+}
+
+// SuggestGasTipCap retrieves the currently suggested gas tip cap after 1559 to
+// allow a timely execution of a transaction.
+func (c *L1Client) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	return c.cfg.SuggestGasTipCap(ctx)
+}
+
+// TransactionReceipt executes the mock TransactionReceipt method.
+func (c *L1Client) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	return c.cfg.TransactionReceipt(ctx, txHash)
+}
+
+// SetBlockNumberFunc overwrites the mock BlockNumber method.
+func (c *L1Client) SetBlockNumberFunc(
+	f func(context.Context) (uint64, error)) {
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.cfg.BlockNumber = f
+}
+
+// SetEstimateGasFunc overwrites the mock EstimateGas method.
+func (c *L1Client) SetEstimateGasFunc(
+	f func(context.Context, ethereum.CallMsg) (uint64, error)) {
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.cfg.EstimateGas = f
+}
+
+// SetHeaderByNumberFunc overwrites the mock HeaderByNumber method.
+func (c *L1Client) SetHeaderByNumberFunc(
+	f func(ctx context.Context, blockNumber *big.Int) (*types.Header, error)) {
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.cfg.HeaderByNumber = f
+}
+
+// SetNonceAtFunc overwrites the mock NonceAt method.
+func (c *L1Client) SetNonceAtFunc(
+	f func(context.Context, common.Address, *big.Int) (uint64, error)) {
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.cfg.NonceAt = f
+}
+
+// SetSendTransactionFunc overwrites the mock SendTransaction method.
+func (c *L1Client) SetSendTransactionFunc(
+	f func(context.Context, *types.Transaction) error) {
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.cfg.SendTransaction = f
+}
+
+// SetSuggestGasTipCapFunc overwrites themock SuggestGasTipCap method.
+func (c *L1Client) SetSuggestGasTipCapFunc(
+	f func(context.Context) (*big.Int, error)) {
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.cfg.SuggestGasTipCap = f
+}
+
+// SetTransactionReceiptFunc overwrites the mock TransactionReceipt method.
+func (c *L1Client) SetTransactionReceiptFunc(
+	f func(context.Context, common.Hash) (*types.Receipt, error)) {
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.cfg.TransactionReceipt = f
+}

go/batch-submitter/sentry_log.go → go/bss-core/sentry_log.go

-package batchsubmitter
+package bsscore
 
 import (
 	"errors"
 	"io"
+	"time"
 
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/getsentry/sentry-go"
@@ -36,3 +37,14 @@ func SentryStreamHandler(wr io.Writer, fmtr log.Format) log.Handler {
 	})
 	return log.LazyHandler(log.SyncHandler(h))
 }
+
+// TraceRateToFloat64 converts a time.Duration into a valid float64 for the
+// Sentry client. The client only accepts values between 0.0 and 1.0, so this
+// method clamps anything greater than 1 second to 1.0.
+func TraceRateToFloat64(rate time.Duration) float64 {
+	rate64 := float64(rate) / float64(time.Second)
+	if rate64 > 1.0 {
+		rate64 = 1.0
+	}
+	return rate64
+}

go/gas-oracle/go.mod

@@ -3,6 +3,6 @@ module github.com/ethereum-optimism/optimism/go/gas-oracle
 go 1.16
 
 require (
-	github.com/ethereum/go-ethereum v1.10.10
+	github.com/ethereum/go-ethereum v1.10.16
 	github.com/urfave/cli v1.20.0
 )

go/gas-oracle/package.json

 {
   "name": "@eth-optimism/gas-oracle",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "private": true,
   "devDependencies": {}
 }