Merge branch 'develop' into extended-time-without-l1-batches

.changeset/great-cherries-bake.md

+---
+'minimum-balance-agent': patch
+---
+
+Added basic balance monitoring

.circleci/config.yml

@@ -866,6 +866,12 @@ workflows:
           dependencies: "(contracts|core-utils)"
           requires:
             - yarn-monorepo
+      - js-lint-test:
+          name: balance-monitor-tests
+          coverage_flag: balance-monitor-tests
+          package_name: balance-monitor
+          requires:
+            - yarn-monorepo
       - depcheck:
           requires:
             - yarn-monorepo

.github/workflows/release.yml

@@ -482,6 +482,33 @@ jobs:
           push: true
           tags: ethereumoptimism/deployer-bedrock:${{ needs.release.outputs.contracts-bedrock }},ethereumoptimism/deployer-bedrock:latest
 
+  balance-monitor:
+    name: Publish balance-monitor Version ${{ needs.release.outputs.balance-monitor }}
+    needs: release
+    if: needs.release.outputs.balance-monitor != ''
+    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.packages
+          target: balance-monitor
+          push: true
+          tags: ethereumoptimism/balance-monitor:${{ needs.release.outputs.balance-monitor }},ethereumoptimism/balance-monitor:latest
+
   integration_tests:
     name: Publish Integration tests ${{ needs.release.outputs.integration-tests }}
     needs: release

op-e2e/actions/blocktime_test.go

@@ -93,6 +93,10 @@ func TestLargeL1Gaps(gt *testing.T) {
 		makeL2BlockWithAliceTx()
 	}
 
+	n, err := cl.NonceAt(t.Ctx(), dp.Addresses.Alice, nil)
+	require.NoError(t, err)
+	require.Equal(t, uint64(16), n) // 16 valid blocks with txns.
+
 	verifyChainStateOnSequencer(8, 16, 8, 14, 7)
 
 	// Make the really long L1 block. Do include previous batches
@@ -115,14 +119,15 @@ func TestLargeL1Gaps(gt *testing.T) {
 	// We created one transaction for every L2 block. So we should have created 40 transactions.
 	// The first 16 L2 block where included without issue.
 	// Then over the long block, 32s seq drift / 2s block time => 16 blocks with transactions
-	// That leaves 8 blocks without transactions. So we should have 16+16 = 32 transactions on chain.
-	n, err := cl.PendingNonceAt(t.Ctx(), dp.Addresses.Alice)
+	// Then at the last L2 block we reached the next origin, and accept txs again => 17 blocks with transactions
+	// That leaves 7 L2 blocks without transactions. So we should have 16+17 = 33 transactions on chain.
+	n, err = cl.PendingNonceAt(t.Ctx(), dp.Addresses.Alice)
 	require.NoError(t, err)
 	require.Equal(t, uint64(40), n)
 
 	n, err = cl.NonceAt(t.Ctx(), dp.Addresses.Alice, nil)
 	require.NoError(t, err)
-	require.Equal(t, uint64(32), n)
+	require.Equal(t, uint64(33), n)
 
 	// Make more L1 blocks to get past the sequence window for the large range.
 	// Do batch submit the previous L2 blocks.
@@ -148,7 +153,7 @@ func TestLargeL1Gaps(gt *testing.T) {
 	// Recheck nonce. Will fail if no batches where submitted
 	n, err = cl.NonceAt(t.Ctx(), dp.Addresses.Alice, nil)
 	require.NoError(t, err)
-	require.Equal(t, uint64(32), n) // 16 valid blocks with txns. Get seq drift non-empty (32/2 => 16) & 8 forced empty
+	require.Equal(t, uint64(33), n) // 16 valid blocks with txns. Get seq drift non-empty (32/2 => 16) & 7 forced empty
 
 	// Check that the verifier got the same result
 	verifier.ActL1HeadSignal(t)

op-e2e/actions/l1_replica.go

@@ -42,7 +42,7 @@ type L1Replica struct {
 	l1Cfg      *core.Genesis
 	l1Signer   types.Signer
 
-	failL1RPC error // mock error
+	failL1RPC func() error // mock error
 }
 
 // NewL1Replica constructs a L1Replica starting at the given genesis.
@@ -145,10 +145,18 @@ func (s *L1Replica) CanonL1Chain() func(num uint64) *types.Block {
 
 // ActL1RPCFail makes the next L1 RPC request to this node fail
 func (s *L1Replica) ActL1RPCFail(t Testing) {
-	if s.failL1RPC != nil { // already set to fail?
-		t.InvalidAction("already have a mock l1 rpc fail set")
+	failed := false
+	s.failL1RPC = func() error {
+		if failed {
+			return nil
+		}
+		failed = true
+		return errors.New("mock L1 RPC error")
 	}
-	s.failL1RPC = errors.New("mock L1 RPC error")
+}
+
+func (s *L1Replica) MockL1RPCErrors(fn func() error) {
+	s.failL1RPC = fn
 }
 
 func (s *L1Replica) EthClient() *ethclient.Client {
@@ -161,9 +169,11 @@ func (s *L1Replica) RPCClient() client.RPC {
 	return testutils.RPCErrFaker{
 		RPC: client.NewBaseRPCClient(cl),
 		ErrFn: func() error {
-			err := s.failL1RPC
-			s.failL1RPC = nil // reset back, only error once.
-			return err
+			if s.failL1RPC != nil {
+				return s.failL1RPC()
+			} else {
+				return nil
+			}
 		},
 	}
 }

op-e2e/actions/l2_sequencer_test.go

@@ -89,7 +89,7 @@ func TestL2Sequencer_SequencerDrift(gt *testing.T) {
 	sequencer.ActL1HeadSignal(t)
 
 	// Make blocks up till the sequencer drift is about to surpass, but keep the old L1 origin
-	for sequencer.SyncStatus().UnsafeL2.Time+sd.RollupCfg.BlockTime < origin.Time()+sd.RollupCfg.MaxSequencerDrift {
+	for sequencer.SyncStatus().UnsafeL2.Time+sd.RollupCfg.BlockTime <= origin.Time()+sd.RollupCfg.MaxSequencerDrift {
 		sequencer.ActL2KeepL1Origin(t)
 		makeL2BlockWithAliceTx()
 		require.Equal(t, uint64(1), sequencer.SyncStatus().UnsafeL2.L1Origin.Number, "expected to keep old L1 origin")

op-e2e/actions/sync_test.go

+package actions
+
+import (
+	"errors"
+	"math/rand"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDerivationWithFlakyL1RPC(gt *testing.T) {
+	t := NewDefaultTesting(gt)
+	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	sd := e2eutils.Setup(t, dp, defaultAlloc)
+	log := testlog.Logger(t, log.LvlError) // mute all the temporary derivation errors that we forcefully create
+	_, miner, sequencer, _, verifier, _, batcher := setupReorgTestActors(t, dp, sd, log)
+
+	rng := rand.New(rand.NewSource(1234))
+	sequencer.ActL2PipelineFull(t)
+	verifier.ActL2PipelineFull(t)
+
+	// build a L1 chain with 20 blocks and matching L2 chain and batches to test some derivation work
+	miner.ActEmptyBlock(t)
+	for i := 0; i < 20; i++ {
+		sequencer.ActL1HeadSignal(t)
+		sequencer.ActL2PipelineFull(t)
+		sequencer.ActBuildToL1Head(t)
+		batcher.ActSubmitAll(t)
+		miner.ActL1StartBlock(12)(t)
+		miner.ActL1IncludeTx(batcher.batcherAddr)(t)
+		miner.ActL1EndBlock(t)
+	}
+	// Make verifier aware of head
+	verifier.ActL1HeadSignal(t)
+
+	// Now make the L1 RPC very flaky: requests will randomly fail with 50% chance
+	miner.MockL1RPCErrors(func() error {
+		if rng.Intn(2) == 0 {
+			return errors.New("mock rpc error")
+		}
+		return nil
+	})
+
+	// And sync the verifier
+	verifier.ActL2PipelineFull(t)
+	// Verifier should be synced, even though it hit lots of temporary L1 RPC errors
+	require.Equal(t, sequencer.L2Unsafe(), verifier.L2Safe(), "verifier is synced")
+}

op-node/rollup/driver/sequencer.go

@@ -84,7 +84,11 @@ func (d *Sequencer) StartBuildingBlock(ctx context.Context, l1Origin eth.L1Block
 	// empty blocks (other than the L1 info deposit and any user deposits). We handle this by
 	// setting NoTxPool to true, which will cause the Sequencer to not include any transactions
 	// from the transaction pool.
-	attrs.NoTxPool = uint64(attrs.Timestamp) >= l1Origin.Time+d.config.MaxSequencerDrift
+	attrs.NoTxPool = uint64(attrs.Timestamp) > l1Origin.Time+d.config.MaxSequencerDrift
+
+	d.log.Debug("prepared attributes for new block",
+		"num", l2Head.Number+1, "time", uint64(attrs.Timestamp),
+		"origin", l1Origin, "origin_time", l1Origin.Time, "noTxPool", attrs.NoTxPool)
 
 	// And construct our fork choice state. This is our current fork choice state and will be
 	// updated as a result of executing the block based on the attributes described above.

ops/docker/Dockerfile.packages

@@ -47,6 +47,7 @@ COPY packages/message-relayer/package.json ./packages/message-relayer/package.js
 COPY packages/fault-detector/package.json ./packages/fault-detector/package.json
 COPY packages/replica-healthcheck/package.json ./packages/replica-healthcheck/package.json
 COPY packages/drippie-mon/package.json ./packages/drippie-mon/package.json
+COPY packages/balance-monitor/package.json ./packages/balance-monitor/package.json
 COPY integration-tests/package.json ./integration-tests/package.json
 
 RUN yarn install --frozen-lockfile && yarn cache clean
@@ -81,7 +82,6 @@ WORKDIR /opt/optimism/packages/data-transport-layer
 COPY ./ops/scripts/dtl.sh .
 CMD ["node", "dist/src/services/run.js"]
 
-
 FROM base as integration-tests
 WORKDIR /opt/optimism/integration-tests
 COPY ./ops/scripts/integration-tests.sh ./
@@ -107,3 +107,7 @@ ENTRYPOINT ["npm", "run", "start"]
 FROM base as drippie-mon
 WORKDIR /opt/optimism/packages/drippie-mon
 ENTRYPOINT ["npm", "run", "start"]
+
+FROM base as drippie-mon
+WORKDIR /opt/optimism/packages/balance-monitor
+ENTRYPOINT ["yarn", "run", "start:prod"]

package.json

@@ -31,7 +31,8 @@
       "**/@openzeppelin/*",
       "@eth-optimism/contracts-periphery/ds-test",
       "@eth-optimism/contracts-periphery/forge-std",
-      "@eth-optimism/contracts-periphery/@rari-capital/solmate"
+      "@eth-optimism/contracts-periphery/@rari-capital/solmate",
+      "forta-agent"
     ]
   },
   "private": true,

packages/balance-monitor/.env.example

-CHAINID=
-L1_RPC_URL=
+export L1_RPC_URL=
 
-SEQUENCER_ADDRESS=
-SEQUENCER_WARNING_THRESHOLD=
-SEQUENCER_DANGER_THRESHOLD=
-
-PROPOSER_ADDRESS=
-PROPOSER_WARNING_THRESHOLD=
-PROPOSER_DANGER_THRESHOLD=
+export SEQUENCER_ADDRESS=
+export SEQUENCER_WARNING_THRESHOLD=
+export SEQUENCER_DANGER_THRESHOLD=
 
+export PROPOSER_ADDRESS=
+export PROPOSER_WARNING_THRESHOLD=
+export PROPOSER_DANGER_THRESHOLD=

packages/balance-monitor/package.json

 {
-  "name": "minimum-balance-agent",
+  "name": "@eth-optimism/minimum-balance-agent",
   "version": "0.0.1",
   "description": "Forta Agent that reports whether certain accounts have fallen below some balance",
+  "homepage": "https://github.com/ethereum-optimism/optimism/tree/develop/packages/balance-monitor#readme",
+  "license": "MIT",
+  "author": "Optimism PBC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ethereum-optimism/optimism.git"
+  },
   "scripts": {
-    "build": "echo 'todo'",
+    "build": "tsc -p tsconfig.json",
+    "clean": "rimraf dist/ ./tsconfig.tsbuildinfo",
     "start": "yarn run start:dev",
     "start:dev": "nodemon --watch src --watch forta.config.json -e js,ts,json  --exec 'yarn run build && forta-agent run'",
     "start:prod": "forta-agent run --prod",
     "tx": "yarn run build && forta-agent run --tx",
     "block": "yarn run build && forta-agent run --block",
     "range": "yarn run build && forta-agent run --range",
-    "test": "echo 'todo'"
+    "test": "./scripts/test.sh",
+    "test:coverage": "echo 'todo: configure test coverage' && yarn test",
+    "lint:check": "eslint . --max-warnings=0",
+    "lint:fix": "yarn lint:check --fix",
+    "lint": "yarn lint:fix && yarn lint:check"
   },
   "dependencies": {
     "ethers": "^5.7.2",
     "forta-agent": "^0.1.1"
   },
   "devDependencies": {
+    "@types/chai": "^4.2.18",
+    "@types/mocha": "^8.2.2",
     "@types/nodemon": "^1.19.0",
+    "chai": "^4.3.4",
     "nodemon": "^2.0.8",
+    "ts-mocha": "^10.0.0",
     "typescript": "^4.3.4"
   }
 }

packages/balance-monitor/scripts/test.sh

+#!/bin/bash
+export SEQUENCER_ADDRESS=0xabba
+export SEQUENCER_WARNING_THRESHOLD=1000
+export SEQUENCER_DANGER_THRESHOLD=100
+
+export PROPOSER_ADDRESS=0xacdc
+export PROPOSER_WARNING_THRESHOLD=2000
+export PROPOSER_DANGER_THRESHOLD=200
+
+yarn ts-mocha src/*.spec.ts

packages/balance-monitor/src/agent.spec.ts

+import { HandleBlock, createBlockEvent } from 'forta-agent'
+import { BigNumber, utils } from 'ethers'
+import { expect } from 'chai'
+
+import agent from './agent'
+
+describe('minimum balance agent', async () => {
+  let handleBlock: HandleBlock
+  let mockEthersProvider
+  const blockEvent = createBlockEvent({
+    block: { hash: '0xa', number: 1 } as any,
+  })
+
+  // A function which returns a mock provider to give us values based on the case we want
+  // to test.
+  const mockEthersProviderByCase = (severity: string) => {
+    switch (severity) {
+      case 'safe':
+        return {
+          getBalance: async (addr: string): Promise<BigNumber> => {
+            if (addr === '0xabba') {
+              return utils.parseEther('1001')
+            }
+            if (addr === '0xacdc') {
+              return utils.parseEther('2001')
+            }
+          },
+        } as any
+      default:
+        break
+    }
+  }
+
+  before(() => {
+    handleBlock = agent.provideHandleBlock(mockEthersProvider)
+  })
+
+  describe('handleBlock', async () => {
+    it('returns empty findings if balance is above threshold', async () => {
+      mockEthersProvider = mockEthersProviderByCase('safe')
+      handleBlock = agent.provideHandleBlock(mockEthersProvider)
+      const findings = await handleBlock(blockEvent)
+
+      expect(findings).to.deep.equal([])
+    })
+  })
+})

packages/balance-monitor/src/agent.ts

+import { BlockEvent, Finding, HandleBlock } from 'forta-agent'
+import { BigNumber, providers } from 'ethers'
+
+type AccountAlert = {
+  name: string
+  address: string
+  thresholds: {
+    warning: BigNumber
+    danger: BigNumber
+  }
+}
+
+export const accounts: AccountAlert[] = [
+  {
+    name: 'Sequencer',
+    address: process.env.SEQUENCER_ADDRESS,
+    thresholds: {
+      warning: BigNumber.from(process.env.SEQUENCER_WARNING_THRESHOLD),
+      danger: BigNumber.from(process.env.SEQUENCER_DANGER_THRESHOLD),
+    },
+  },
+  {
+    name: 'Proposer',
+    address: process.env.PROPOSER_ADDRESS,
+    thresholds: {
+      warning: BigNumber.from(process.env.PROPOSER_WARNING_THRESHOLD),
+      danger: BigNumber.from(process.env.PROPOSER_DANGER_THRESHOLD),
+    },
+  },
+]
+
+const provideHandleBlock = (
+  provider: providers.JsonRpcProvider
+): HandleBlock => {
+  return async (blockEvent: BlockEvent) => {
+    // report finding if specified account balance falls below threshold
+    const findings: Finding[] = []
+
+    // iterate over accounts with the index
+    for (const [idx, account] of accounts.entries()) {
+      const accountBalance = BigNumber.from(
+        (
+          await provider.getBalance(account.address, blockEvent.blockNumber)
+        ).toString()
+      )
+      if (accountBalance.gte(account.thresholds.warning)) {
+        // todo: add to the findings array when balances are below the threshold
+        // return if this is the last account
+        if (idx === accounts.length - 1) {
+          return findings
+        }
+      }
+    }
+
+    return findings
+  }
+}
+
+const l1Provider = new providers.JsonRpcProvider(process.env.L1_RPC_URL)
+
+export default {
+  provideHandleBlock,
+  handleBlock: provideHandleBlock(l1Provider),
+}

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

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

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

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

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

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

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

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

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

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

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

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

specs/withdrawals.md

@@ -22,7 +22,7 @@ more specific terms to differentiate:
   withdrawal.
 
 Withdrawals are initiated on L2 via a call to the Message Passer predeploy contract, which records the important
-properties of the message in its storage. Withdrawals are finalized on L1 via a call to the `L2WithdrawalVerifier`
+properties of the message in its storage. Withdrawals are finalized on L1 via a call to the `OptimismPortal`
 contract, which proves the inclusion of this withdrawal message.
 
 In this way, withdrawals are different from [deposits][g-deposits] which make use of a special transaction type in the