feat(ctp): introduce Drippie and rework deploy (#2569)

Drippie is a helper contract for managing automatic contract
interactions. Drippie is meant to be deployed as a middle layer between
our contracts and other automation services like Gelato. This commit
also revamps the deployment process to use hardhat-deploy deterministic
deployments, ledger support, and better authentication.

.changeset/few-comics-fly.md

+---
+'@eth-optimism/contracts-periphery': patch
+---
+
+Introduce the Drippie peripheral contract for managing ETH drips

.circleci/config.yml

@@ -116,6 +116,19 @@ jobs:
           command: yarn test:slither
           working_directory: packages/contracts
 
+  contracts-periphery-slither:
+    docker:
+      - image: ethereumoptimism/js-builder:latest
+    steps:
+      - restore_cache:
+          keys:
+            - v2-cache-yarn-build-{{ .Revision }}
+      - checkout
+      - run:
+          name: Run Slither
+          command: yarn test:slither
+          working_directory: packages/contracts-periphery
+
   contracts-tests:
     docker:
       - image: ethereumoptimism/js-builder:latest
@@ -155,6 +168,10 @@ jobs:
           name: Lint
           command: yarn lint:check
           working_directory: packages/contracts-periphery
+      - run:
+          name: Slither
+          command: yarn test:slither
+          working_directory: packages/contracts
       - run:
           name: Test
           command: yarn test:coverage

packages/contracts-periphery/.env.example

 # Etherscan API key for Ethereum and Ethereum testnets
-ETHERSCAN_API_KEY=
+ETHEREUM_ETHERSCAN_API_KEY=
 
 # Etherscan API key for Optimism and Optimism testnets
 OPTIMISTIC_ETHERSCAN_API_KEY=
+
+# Ledger required to deploy stuff, insert address here
+LEDGER_ADDRESS=
+
+# Required to deploy to Ethereum or Ethereum testnets
+INFURA_PROJECT_ID=

packages/contracts-periphery/contracts/testing/helpers/CallRecorder.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+contract CallRecorder {
+    struct CallInfo {
+        address sender;
+        bytes data;
+        uint256 gas;
+        uint256 value;
+    }
+
+    CallInfo public lastCall;
+
+    function record() public payable {
+        lastCall.sender = msg.sender;
+        lastCall.data = msg.data;
+        lastCall.gas = gasleft();
+        lastCall.value = msg.value;
+    }
+}

packages/contracts-periphery/contracts/testing/helpers/Reverter.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+contract Reverter {
+    function doRevert() public pure {
+        revert("Reverter reverted");
+    }
+}

packages/contracts-periphery/contracts/testing/helpers/SimpleStorage.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+contract SimpleStorage {
+    mapping(bytes32 => bytes32) public db;
+
+    function set(bytes32 _key, bytes32 _value) public payable {
+        db[_key] = _value;
+    }
+
+    function get(bytes32 _key) public view returns (bytes32) {
+        return db[_key];
+    }
+}

packages/contracts-periphery/contracts/universal/RetroReceiver.sol → packages/contracts-periphery/contracts/universal/AssetReceiver.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.9;
 
-import { Owned } from "@rari-capital/solmate/src/auth/Owned.sol";
-import { ERC20 } from "@rari-capital/solmate/src/tokens/ERC20.sol";
-import { ERC721 } from "@rari-capital/solmate/src/tokens/ERC721.sol";
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import { Transactor } from "./Transactor.sol";
 
 /**
- * @title RetroReceiver
- * @notice RetroReceiver is a minimal contract for receiving funds, meant to be deployed at the
- * same address on every chain that supports EIP-2470.
+ * @title AssetReceiver
+ * @notice AssetReceiver is a minimal contract for receiving funds assets in the form of either
+ * ETH, ERC20 tokens, or ERC721 tokens. Only the contract owner may withdraw the assets.
  */
-contract RetroReceiver is Owned {
+contract AssetReceiver is Transactor {
     /**
      * Emitted when ETH is received by this address.
      */
@@ -42,9 +42,9 @@ contract RetroReceiver is Owned {
     );
 
     /**
-     * @param _owner Address to initially own the contract.
+     * @param _owner Initial contract owner.
      */
-    constructor(address _owner) Owned(_owner) {}
+    constructor(address _owner) Transactor(_owner) {}
 
     /**
      * Make sure we can receive ETH.
@@ -58,7 +58,7 @@ contract RetroReceiver is Owned {
      *
      * @param _to Address to receive the ETH balance.
      */
-    function withdrawETH(address payable _to) public onlyOwner {
+    function withdrawETH(address payable _to) external onlyOwner {
         withdrawETH(_to, address(this).balance);
     }
 
@@ -69,6 +69,7 @@ contract RetroReceiver is Owned {
      * @param _amount Amount of ETH to withdraw.
      */
     function withdrawETH(address payable _to, uint256 _amount) public onlyOwner {
+        // slither-disable-next-line reentrancy-unlimited-gas
         _to.transfer(_amount);
         emit WithdrewETH(msg.sender, _to, _amount);
     }
@@ -79,7 +80,7 @@ contract RetroReceiver is Owned {
      * @param _asset ERC20 token to withdraw.
      * @param _to Address to receive the ERC20 balance.
      */
-    function withdrawERC20(ERC20 _asset, address _to) public onlyOwner {
+    function withdrawERC20(ERC20 _asset, address _to) external onlyOwner {
         withdrawERC20(_asset, _to, _asset.balanceOf(address(this)));
     }
 
@@ -95,7 +96,9 @@ contract RetroReceiver is Owned {
         address _to,
         uint256 _amount
     ) public onlyOwner {
+        // slither-disable-next-line unchecked-transfer
         _asset.transfer(_to, _amount);
+        // slither-disable-next-line reentrancy-events
         emit WithdrewERC20(msg.sender, _to, address(_asset), _amount);
     }
 
@@ -110,8 +113,9 @@ contract RetroReceiver is Owned {
         ERC721 _asset,
         address _to,
         uint256 _id
-    ) public onlyOwner {
+    ) external onlyOwner {
         _asset.transferFrom(address(this), _to, _id);
+        // slither-disable-next-line reentrancy-events
         emit WithdrewERC721(msg.sender, _to, address(_asset), _id);
     }
 }

packages/contracts-periphery/contracts/universal/Transactor.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title Transactor
+ * @notice Transactor is a minimal contract that can send transactions.
+ */
+contract Transactor is Ownable {
+    /**
+     * @param _owner Initial contract owner.
+     */
+    constructor(address _owner) Ownable() {
+        transferOwnership(_owner);
+    }
+
+    /**
+     * Sends a CALL to a target address.
+     *
+     * @param _target Address to call.
+     * @param _data Data to send with the call.
+     * @param _gas Amount of gas to send with the call.
+     * @param _value ETH value to send with the call.
+     * @return Boolean success value.
+     * @return Bytes data returned by the call.
+     */
+    function CALL(
+        address _target,
+        bytes memory _data,
+        uint256 _gas,
+        uint256 _value
+    ) external payable onlyOwner returns (bool, bytes memory) {
+        return _target.call{ gas: _gas, value: _value }(_data);
+    }
+
+    /**
+     * Sends a DELEGATECALL to a target address.
+     *
+     * @param _target Address to call.
+     * @param _data Data to send with the call.
+     * @param _gas Amount of gas to send with the call.
+     * @return Boolean success value.
+     * @return Bytes data returned by the call.
+     */
+    function DELEGATECALL(
+        address _target,
+        bytes memory _data,
+        uint256 _gas
+    ) external payable onlyOwner returns (bool, bytes memory) {
+        // slither-disable-next-line controlled-delegatecall
+        return _target.delegatecall{ gas: _gas }(_data);
+    }
+}

packages/contracts-periphery/contracts/universal/drippie/IDripCheck.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+interface IDripCheck {
+    // DripCheck contracts that want to take parameters as inputs MUST expose a struct called
+    // Params and an event _EventForExposingParamsStructInABI(Params params). This makes it
+    // possible to easily encode parameters on the client side. Solidity does not support generics
+    // so it's not possible to do this with explicit typing.
+
+    function check(bytes memory _params) external view returns (bool);
+}

packages/contracts-periphery/contracts/universal/drippie/dripchecks/CheckBalanceHigh.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import { IDripCheck } from "../IDripCheck.sol";
+
+/**
+ * @title CheckBalanceHigh
+ * @notice DripCheck for checking if an account's balance is above a given threshold.
+ */
+contract CheckBalanceHigh is IDripCheck {
+    event _EventToExposeStructInABI__Params(Params params);
+    struct Params {
+        address target;
+        uint256 threshold;
+    }
+
+    function check(bytes memory _params) external view returns (bool) {
+        Params memory params = abi.decode(_params, (Params));
+
+        // Check target balance is above threshold.
+        return params.target.balance > params.threshold;
+    }
+}

packages/contracts-periphery/contracts/universal/drippie/dripchecks/CheckBalanceLow.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import { IDripCheck } from "../IDripCheck.sol";
+
+/**
+ * @title CheckBalanceLow
+ * @notice DripCheck for checking if an account's balance is below a given threshold.
+ */
+contract CheckBalanceLow is IDripCheck {
+    event _EventToExposeStructInABI__Params(Params params);
+    struct Params {
+        address target;
+        uint256 threshold;
+    }
+
+    function check(bytes memory _params) external view returns (bool) {
+        Params memory params = abi.decode(_params, (Params));
+
+        // Check target ETH balance is below threshold.
+        return params.target.balance < params.threshold;
+    }
+}

packages/contracts-periphery/contracts/universal/drippie/dripchecks/CheckGelatoLow.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import { IDripCheck } from "../IDripCheck.sol";
+
+interface IGelatoTreasury {
+    function userTokenBalance(address _user, address _token) external view returns (uint256);
+}
+
+/**
+ * @title CheckGelatoLow
+ * @notice DripCheck for checking if an account's Gelato ETH balance is below some threshold.
+ */
+contract CheckGelatoLow is IDripCheck {
+    event _EventToExposeStructInABI__Params(Params params);
+    struct Params {
+        address treasury;
+        uint256 threshold;
+        address recipient;
+    }
+
+    function check(bytes memory _params) external view returns (bool) {
+        Params memory params = abi.decode(_params, (Params));
+
+        // Check GelatoTreasury ETH balance is below threshold.
+        return
+            IGelatoTreasury(params.treasury).userTokenBalance(
+                params.recipient,
+                // Gelato represents ETH as 0xeeeee....eeeee
+                0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE
+            ) < params.threshold;
+    }
+}

packages/contracts-periphery/contracts/universal/drippie/dripchecks/CheckTrue.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import { IDripCheck } from "../IDripCheck.sol";
+
+/**
+ * @title CheckTrue
+ * @notice DripCheck that always returns true.
+ */
+contract CheckTrue is IDripCheck {
+    function check(bytes memory) external pure returns (bool) {
+        return true;
+    }
+}

packages/contracts-periphery/deploy/RetroReceiver.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+import { getDeployConfig } from '../src'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deployer } = await hre.getNamedAccounts()
+
+  const config = getDeployConfig(hre.network.name)
+
+  const { deploy } = await hre.deployments.deterministic('AssetReceiver', {
+    salt: hre.ethers.utils.solidityKeccak256(['string'], ['RetroReceiver']),
+    from: deployer,
+    args: [config.retroReceiverOwner],
+    log: true,
+  })
+
+  await deploy()
+}
+
+deployFn.tags = ['RetroReceiver']
+deployFn.dependencies = ['OptimismAuthority']
+
+export default deployFn

packages/contracts-periphery/deploy/drippie/Drippie.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+import { getDeployConfig } from '../../src'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deployer } = await hre.getNamedAccounts()
+
+  const config = getDeployConfig(hre.network.name)
+
+  const { deploy } = await hre.deployments.deterministic('Drippie', {
+    salt: hre.ethers.utils.solidityKeccak256(['string'], ['Drippie']),
+    from: deployer,
+    args: [config.drippieOwner],
+    log: true,
+  })
+
+  await deploy()
+}
+
+deployFn.tags = ['Drippie']
+deployFn.dependencies = ['OptimismAuthority']
+
+export default deployFn

packages/contracts-periphery/deploy/drippie/dripchecks/CheckBalanceHigh.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deployer } = await hre.getNamedAccounts()
+
+  const { deploy } = await hre.deployments.deterministic('CheckBalanceHigh', {
+    salt: hre.ethers.utils.solidityKeccak256(['string'], ['CheckBalanceHigh']),
+    from: deployer,
+    log: true,
+  })
+
+  await deploy()
+}
+
+deployFn.tags = ['CheckBalanceHigh']
+
+export default deployFn

packages/contracts-periphery/deploy/drippie/dripchecks/CheckBalanceLow.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deployer } = await hre.getNamedAccounts()
+
+  const { deploy } = await hre.deployments.deterministic('CheckBalanceLow', {
+    salt: hre.ethers.utils.solidityKeccak256(['string'], ['CheckBalanceLow']),
+    from: deployer,
+    log: true,
+  })
+
+  await deploy()
+}
+
+deployFn.tags = ['CheckBalanceLow']
+
+export default deployFn

packages/contracts-periphery/deploy/drippie/dripchecks/CheckGelatoLow.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deployer } = await hre.getNamedAccounts()
+
+  const { deploy } = await hre.deployments.deterministic('CheckGelatoLow', {
+    salt: hre.ethers.utils.solidityKeccak256(['string'], ['CheckGelatoLow']),
+    from: deployer,
+    log: true,
+  })
+
+  await deploy()
+}
+
+deployFn.tags = ['CheckGelatoLow']
+
+export default deployFn

packages/contracts-periphery/deploy/drippie/dripchecks/CheckTrue.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deployer } = await hre.getNamedAccounts()
+
+  const { deploy } = await hre.deployments.deterministic('CheckTrue', {
+    salt: hre.ethers.utils.solidityKeccak256(['string'], ['CheckTrue']),
+    from: deployer,
+    log: true,
+  })
+
+  await deploy()
+}
+
+deployFn.tags = ['CheckTrue']
+
+export default deployFn

packages/contracts-periphery/hardhat.config.ts

@@ -7,6 +7,8 @@ import '@nomiclabs/hardhat-ethers'
 import '@nomiclabs/hardhat-waffle'
 import '@nomiclabs/hardhat-etherscan'
 import 'solidity-coverage'
+import 'hardhat-gas-reporter'
+import 'hardhat-deploy'
 
 // Hardhat tasks
 import './tasks'
@@ -18,15 +20,57 @@ const config: HardhatUserConfig = {
   networks: {
     optimism: {
       chainId: 10,
-      url: 'https://mainnet.optimsim.io',
+      url: 'https://mainnet.optimism.io',
+      verify: {
+        etherscan: {
+          apiKey: getenv('OPTIMISTIC_ETHERSCAN_API_KEY'),
+        },
+      },
     },
     opkovan: {
       chainId: 69,
       url: 'https://kovan.optimism.io',
+      verify: {
+        etherscan: {
+          apiKey: getenv('OPTIMISTIC_ETHERSCAN_API_KEY'),
+        },
+      },
     },
-    mainnet: {
+    ethereum: {
       chainId: 1,
-      url: 'https://rpc.ankr.com/eth',
+      url: `https://mainnet.infura.io/v3/${getenv('INFURA_PROJECT_ID')}`,
+      verify: {
+        etherscan: {
+          apiKey: getenv('ETHEREUM_ETHERSCAN_API_KEY'),
+        },
+      },
+    },
+    goerli: {
+      chainId: 5,
+      url: `https://goerli.infura.io/v3/${getenv('INFURA_PROJECT_ID')}`,
+      verify: {
+        etherscan: {
+          apiKey: getenv('ETHEREUM_ETHERSCAN_API_KEY'),
+        },
+      },
+    },
+    ropsten: {
+      chainId: 3,
+      url: `https://ropsten.infura.io/v3/${getenv('INFURA_PROJECT_ID')}`,
+      verify: {
+        etherscan: {
+          apiKey: getenv('ETHEREUM_ETHERSCAN_API_KEY'),
+        },
+      },
+    },
+    kovan: {
+      chainId: 42,
+      url: `https://kovan.infura.io/v3/${getenv('INFURA_PROJECT_ID')}`,
+      verify: {
+        etherscan: {
+          apiKey: getenv('ETHEREUM_ETHERSCAN_API_KEY'),
+        },
+      },
     },
   },
   mocha: {
@@ -52,12 +96,8 @@ const config: HardhatUserConfig = {
       },
     },
   },
-  etherscan: {
-    apiKey: {
-      mainnet: getenv('ETHERSCAN_API_KEY'),
-      optimisticEthereum: getenv('OPTIMISTIC_ETHERSCAN_API_KEY'),
-      optimisticKovan: getenv('OPTIMISTIC_ETHERSCAN_API_KEY'),
-    },
+  namedAccounts: {
+    deployer: `ledger://${getenv('LEDGER_ADDRESS')}`,
   },
 }
 

packages/contracts-periphery/package.json

@@ -21,6 +21,9 @@
     "test": "yarn test:contracts",
     "test:contracts": "hardhat test --show-stack-traces",
     "test:coverage": "NODE_OPTIONS=--max_old_space_size=8192 hardhat coverage && istanbul check-coverage --statements 90 --branches 84 --functions 88 --lines 90",
+    "test:slither": "slither .",
+    "pretest:slither": "rm -f @openzeppelin && rm -f hardhat && ln -s node_modules/@openzeppelin @openzeppelin && ln -s ../../node_modules/hardhat hardhat",
+    "posttest:slither": "rm -f @openzeppelin && rm -f hardhat",
     "lint:ts:check": "eslint . --max-warnings=0",
     "lint:contracts:check": "yarn solhint -f table 'contracts/**/*.sol'",
     "lint:check": "yarn lint:contracts:check && yarn lint:ts:check",
@@ -49,16 +52,14 @@
     "type": "git",
     "url": "https://github.com/ethereum-optimism/optimism.git"
   },
-  "dependencies": {
-    "@eth-optimism/core-utils": "^0.8.5",
-    "@openzeppelin/contracts": "4.3.2"
-  },
   "devDependencies": {
+    "@defi-wonderland/smock": "^2.0.7",
+    "@eth-optimism/core-utils": "^0.8.5",
     "@ethersproject/hardware-wallets": "^5.6.1",
     "@nomiclabs/hardhat-ethers": "^2.0.2",
     "@nomiclabs/hardhat-etherscan": "^3.0.3",
     "@nomiclabs/hardhat-waffle": "^2.0.1",
-    "@rari-capital/solmate": "^6.3.0",
+    "@openzeppelin/contracts": "4.6.0",
     "@types/chai": "^4.2.18",
     "@types/mocha": "^8.2.2",
     "@types/node": "^17.0.21",
@@ -80,9 +81,11 @@
     "ethers": "^5.6.8",
     "hardhat": "^2.9.6",
     "hardhat-deploy": "^0.11.10",
+    "hardhat-gas-reporter": "^1.0.8",
     "istanbul": "^0.4.5",
     "lint-staged": "11.0.0",
     "mocha": "^8.4.0",
+    "node-fetch": "^2.6.7",
     "prettier": "^2.3.1",
     "prettier-plugin-solidity": "^1.0.0-beta.18",
     "solhint": "^3.3.6",

packages/contracts-periphery/slither.config.json

@@ -8,5 +8,5 @@
   "hardhat_ignore_compile": false,
   "disable_color": false,
   "exclude_dependencies": false,
-  "filter_paths": "@openzeppelin|hardhat|contracts/test-helpers|contracts/test-libraries|contracts/L2/predeploys/WETH9.sol"
+  "filter_paths": "@openzeppelin|hardhat|contracts/testing"
 }

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

+import { ethers } from 'ethers'
+
+/**
+ * Defines the configuration for a deployment.
+ */
+export interface DeployConfig {
+  /**
+   * Initial RetroReceiver owner.
+   */
+  retroReceiverOwner: string
+
+  /**
+   * Initial Drippie owner.
+   */
+  drippieOwner: string
+}
+
+/**
+ * Specification for each of the configuration options.
+ */
+const configSpec: {
+  [K in keyof DeployConfig]: {
+    type: string
+    default?: any
+  }
+} = {
+  retroReceiverOwner: {
+    type: 'address',
+  },
+  drippieOwner: {
+    type: 'address',
+  },
+}
+
+/**
+ * Gets the deploy config for the given network.
+ *
+ * @param network Network name.
+ * @returns Deploy config for the given network.
+ */
+export const getDeployConfig = (network: string): Required<DeployConfig> => {
+  let config: DeployConfig
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    config = require(`../../config/deploy/${network}.ts`).default
+  } catch (err) {
+    throw new Error(
+      `error while loading deploy config for network: ${network}, ${err}`
+    )
+  }
+
+  return parseDeployConfig(config)
+}
+
+/**
+ * Parses and validates the given deploy config, replacing any missing values with defaults.
+ *
+ * @param config Deploy config to parse.
+ * @returns Parsed deploy config.
+ */
+export const parseDeployConfig = (
+  config: DeployConfig
+): Required<DeployConfig> => {
+  // Create a clone of the config object. Shallow clone is fine because none of the input options
+  // are expected to be objects or functions etc.
+  const parsed = { ...config }
+
+  for (const [key, spec] of Object.entries(configSpec)) {
+    // Make sure the value is defined, or use a default.
+    if (parsed[key] === undefined) {
+      if ('default' in spec) {
+        parsed[key] = spec.default
+      } else {
+        throw new Error(
+          `deploy config is missing required field: ${key} (${spec.type})`
+        )
+      }
+    } else {
+      // Make sure the default has the correct type.
+      if (spec.type === 'address') {
+        if (!ethers.utils.isAddress(parsed[key])) {
+          throw new Error(
+            `deploy config field: ${key} is not of type ${spec.type}: ${parsed[key]}`
+          )
+        }
+      } else if (typeof parsed[key] !== spec.type) {
+        throw new Error(
+          `deploy config field: ${key} is not of type ${spec.type}: ${parsed[key]}`
+        )
+      }
+    }
+  }
+
+  return parsed as Required<DeployConfig>
+}

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

+import assert from 'assert'
+
+import { BigNumberish, ethers } from 'ethers'
+import { Interface } from 'ethers/lib/utils'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+
+import { Etherscan } from '../etherscan'
+
+export interface DripConfig {
+  interval: BigNumberish
+  dripcheck: string
+  checkparams?: any
+  actions: Array<{
+    target: string
+    value?: BigNumberish
+    data?:
+      | string
+      | {
+          fn: string
+          args: any[]
+        }
+  }>
+}
+
+export interface DrippieConfig {
+  [name: string]: DripConfig
+}
+
+export const getDrippieConfig = async (
+  hre: HardhatRuntimeEnvironment
+): Promise<Required<DrippieConfig>> => {
+  let config: DrippieConfig
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    config = require(`../../config/drippie/${hre.network.name}.ts`).default
+  } catch (err) {
+    throw new Error(
+      `error while loading drippie config for network: ${hre.network.name}, ${err}`
+    )
+  }
+
+  return parseDrippieConfig(hre, config)
+}
+
+export const encodeDripCheckParams = (
+  iface: Interface,
+  params: any
+): string => {
+  return ethers.utils.defaultAbiCoder.encode(
+    [iface.getEvent('_EventToExposeStructInABI__Params').inputs[0]],
+    [params]
+  )
+}
+
+export const parseDrippieConfig = async (
+  hre: HardhatRuntimeEnvironment,
+  config: DrippieConfig
+): Promise<Required<DrippieConfig>> => {
+  // Create a clone of the config object. Shallow clone is fine because none of the input options
+  // are expected to be objects or functions etc.
+  const parsed = { ...config }
+
+  const etherscan = new Etherscan(
+    hre.network.config.verify.etherscan.apiKey,
+    hre.network.config.chainId
+  )
+
+  for (const dripConfig of Object.values(parsed)) {
+    for (const action of dripConfig.actions) {
+      assert(ethers.utils.isAddress(action.target), 'target is not an address')
+
+      if (action.data === undefined) {
+        action.data = '0x'
+      } else if (typeof action.data === 'string') {
+        assert(
+          ethers.utils.isHexString(action.data),
+          'action is not a hex string'
+        )
+      } else {
+        const abi = await etherscan.getContractABI(action.target)
+        const iface = new ethers.utils.Interface(abi)
+        action.data = iface.encodeFunctionData(action.data.fn, action.data.args)
+      }
+
+      if (action.value === undefined) {
+        action.value = ethers.BigNumber.from(0)
+      } else {
+        action.value = ethers.BigNumber.from(action.value)
+      }
+    }
+
+    const dripcheck = await hre.deployments.get(dripConfig.dripcheck)
+    dripConfig.dripcheck = dripcheck.address
+
+    if (dripConfig.checkparams === undefined) {
+      dripConfig.checkparams = '0x'
+    } else {
+      dripConfig.checkparams = encodeDripCheckParams(
+        new ethers.utils.Interface(dripcheck.abi),
+        dripConfig.checkparams
+      )
+    }
+
+    dripConfig.interval = ethers.BigNumber.from(dripConfig.interval)
+  }
+
+  return parsed as Required<DrippieConfig>
+}

packages/contracts-periphery/src/config/index.ts

+export * from './deploy'
+export * from './drippie'

packages/contracts-periphery/src/etherscan.ts

+import fetch from 'node-fetch'
+
+interface NetworkData {
+  chainId: number
+  names: string[]
+  etherscanApiUrl: string
+}
+
+const networks: {
+  [id: number]: NetworkData
+} = {
+  1: {
+    chainId: 1,
+    names: ['mainnet', 'main', 'eth', 'ethereum'],
+    etherscanApiUrl: 'https://api.etherscan.io',
+  },
+  3: {
+    chainId: 3,
+    names: ['ropsten'],
+    etherscanApiUrl: 'https://api-ropsten.etherscan.io',
+  },
+  4: {
+    chainId: 4,
+    names: ['rinkeby'],
+    etherscanApiUrl: 'https://api-rinkeby.etherscan.io',
+  },
+  5: {
+    chainId: 5,
+    names: ['goerli'],
+    etherscanApiUrl: 'https://api-goerli.etherscan.io',
+  },
+  10: {
+    chainId: 10,
+    names: ['optimism'],
+    etherscanApiUrl: 'https://api-optimistic.etherscan.io',
+  },
+  42: {
+    chainId: 42,
+    names: ['kovan'],
+    etherscanApiUrl: 'https://api-kovan.etherscan.io',
+  },
+  69: {
+    chainId: 69,
+    names: ['opkovan', 'kovan-optimism', 'optimistic-kovan'],
+    etherscanApiUrl: 'https://api-kovan-optimistic.etherscan.io',
+  },
+}
+
+export class Etherscan {
+  net: NetworkData
+
+  constructor(
+    private readonly apiKey: string,
+    private readonly network: string | number
+  ) {
+    if (typeof network === 'string') {
+      this.net = Object.values(networks).find((net) => {
+        return net.names.includes(network)
+      })
+    } else {
+      this.net = networks[this.network]
+    }
+  }
+
+  public async getContractSource(address: string): Promise<any> {
+    const url = new URL(`${this.net.etherscanApiUrl}/api`)
+    url.searchParams.append('module', 'contract')
+    url.searchParams.append('action', 'getsourcecode')
+    url.searchParams.append('address', address)
+    url.searchParams.append('apikey', this.apiKey)
+    const response = await fetch(url)
+    const result = await response.json()
+    return result.result[0]
+  }
+
+  public async getContractABI(address: string): Promise<any> {
+    const source = await this.getContractSource(address)
+    if (source.Proxy === '1') {
+      const impl = await this.getContractSource(source.Implementation)
+      return impl.ABI
+    } else {
+      return source.ABI
+    }
+  }
+}

packages/contracts-periphery/src/index.ts

+export * from './config'
+export * from './etherscan'

packages/contracts-periphery/tasks/deploy-receiver.ts

-import { task } from 'hardhat/config'
-import * as types from 'hardhat/internal/core/params/argumentTypes'
-import { LedgerSigner } from '@ethersproject/hardware-wallets'
-
-task('deploy-receiver')
-  .addParam('creator', 'Creator address', undefined, types.string)
-  .addParam('owner', 'Owner address', undefined, types.string)
-  .setAction(async (args, hre) => {
-    console.log(`connecting to ledger...`)
-    const signer = new LedgerSigner(
-      hre.ethers.provider,
-      'default',
-      hre.ethers.utils.defaultPath
-    )
-
-    const addr = await signer.getAddress()
-    if (args.creator !== addr) {
-      throw new Error(`Incorrect key. Creator ${args.creator}, Signer ${addr}`)
-    }
-
-    const singleton = new hre.ethers.Contract(
-      '0xce0042B868300000d44A59004Da54A005ffdcf9f',
-      [
-        {
-          constant: false,
-          inputs: [
-            {
-              internalType: 'bytes',
-              name: '_initCode',
-              type: 'bytes',
-            },
-            {
-              internalType: 'bytes32',
-              name: '_salt',
-              type: 'bytes32',
-            },
-          ],
-          name: 'deploy',
-          outputs: [
-            {
-              internalType: 'address payable',
-              name: 'createdContract',
-              type: 'address',
-            },
-          ],
-          payable: false,
-          stateMutability: 'nonpayable',
-          type: 'function',
-        },
-      ],
-      signer
-    )
-
-    const salt =
-      '0x0000000000000000000000000000000000000000000000000000000000000001'
-    const code = hre.ethers.utils.hexConcat([
-      hre.artifacts.readArtifactSync('RetroReceiver').bytecode,
-      hre.ethers.utils.defaultAbiCoder.encode(['address'], [addr]),
-    ])
-
-    // Predict and connect to the contract address
-    const receiver = await hre.ethers.getContractAt(
-      'RetroReceiver',
-      await singleton.callStatic.deploy(code, salt, {
-        gasLimit: 2_000_000,
-      }),
-      signer
-    )
-
-    console.log(`creating contract: ${receiver.address}...`)
-    const tx1 = await singleton.deploy(code, salt, {
-      gasLimit: 2_000_000,
-    })
-
-    console.log(`waiting for tx: ${tx1.hash}...`)
-    await tx1.wait()
-
-    console.log(`transferring ownership to: ${args.owner}...`)
-    const tx2 = await receiver.setOwner(args.owner)
-
-    console.log(`waiting for tx: ${tx2.hash}...`)
-    await tx2.wait()
-
-    console.log(`verifying contract: ${receiver.address}...`)
-    await hre.run('verify:verify', {
-      address: receiver.address,
-      constructorArguments: [addr],
-    })
-
-    console.log(`all done`)
-  })

packages/contracts-periphery/tasks/index.ts

-export * from './deploy-receiver'
+export * from './install-drippie-config'

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

+import { task } from 'hardhat/config'
+import { LedgerSigner } from '@ethersproject/hardware-wallets'
+import { PopulatedTransaction } from 'ethers'
+
+import { DripConfig, getDrippieConfig } from '../src'
+
+task('install-drippie-config').setAction(async (args, hre) => {
+  console.log(`connecting to ledger...`)
+  const signer = new LedgerSigner(
+    hre.ethers.provider,
+    'default',
+    hre.ethers.utils.defaultPath
+  )
+
+  console.log(`connecting to Drippie...`)
+  const Drippie = await hre.ethers.getContractAt(
+    'Drippie',
+    (
+      await hre.deployments.get('Drippie')
+    ).address,
+    signer
+  )
+
+  console.log(`loading local version of Drippie config for network...`)
+  const config = await getDrippieConfig(hre)
+
+  // Need this to deal with annoying Ethers/Ledger 1559 issue.
+  const sendtx = async (tx: PopulatedTransaction): Promise<void> => {
+    const gas = await signer.estimateGas(tx)
+    tx.type = 1
+    tx.gasLimit = gas
+    const ret = await signer.sendTransaction(tx)
+    console.log(`sent tx: ${ret.hash}`)
+    console.log(`waiting for tx to be confirmed...`)
+    await ret.wait()
+    console.log(`tx confirmed`)
+  }
+
+  const isSameConfig = (a: DripConfig, b: DripConfig): boolean => {
+    return (
+      a.dripcheck.toLowerCase() === b.dripcheck.toLowerCase() &&
+      a.checkparams === b.checkparams &&
+      hre.ethers.BigNumber.from(a.interval).eq(b.interval) &&
+      a.actions.length === b.actions.length &&
+      a.actions.every((ax, i) => {
+        return (
+          ax.target === b.actions[i].target &&
+          ax.data === b.actions[i].data &&
+          hre.ethers.BigNumber.from(ax.value).eq(b.actions[i].value)
+        )
+      })
+    )
+  }
+
+  console.log(`installing Drippie config file...`)
+  for (const [dripName, dripConfig] of Object.entries(config)) {
+    console.log(`checking config for drip: ${dripName}`)
+    const drip = await Drippie.drips(dripName)
+    if (drip.status === 0) {
+      console.log(`drip does not exist yet: ${dripName}`)
+      console.log(`creating drip...`)
+      const tx = await Drippie.populateTransaction.create(dripName, dripConfig)
+      await sendtx(tx)
+    } else if (!isSameConfig(dripConfig, drip.config)) {
+      console.log(`drip exists but local config is different: ${dripName}`)
+      console.log(`drips cannot be modified for security reasons`)
+      console.log(`please do not modify the local config for existing drips`)
+      console.log(`you can archive the old drip and create another`)
+    } else {
+      console.log(`drip is already installed`)
+    }
+  }
+
+  console.log(`config is fully installed`)
+})

packages/contracts-periphery/test/contracts/universal/RetroReceiver.spec.ts → packages/contracts-periphery/test/contracts/universal/AssetReceiver.spec.ts

@@ -5,7 +5,7 @@ import { Contract } from 'ethers'
 import { expect } from '../../setup'
 import { deploy } from '../../helpers'
 
-describe('RetroReceiver', () => {
+describe('AssetReceiver', () => {
   const DEFAULT_TOKEN_ID = 0
   const DEFAULT_AMOUNT = hre.ethers.constants.WeiPerEther
   const DEFAULT_RECIPIENT = '0x' + '11'.repeat(20)
@@ -18,11 +18,11 @@ describe('RetroReceiver', () => {
 
   let TestERC20: Contract
   let TestERC721: Contract
-  let RetroReceiver: Contract
+  let AssetReceiver: Contract
   beforeEach('deploy contracts', async () => {
     TestERC20 = await deploy('TestERC20', { signer: signer1 })
     TestERC721 = await deploy('TestERC721', { signer: signer1 })
-    RetroReceiver = await deploy('RetroReceiver', {
+    AssetReceiver = await deploy('AssetReceiver', {
       signer: signer1,
       args: [signer1.address],
     })
@@ -37,41 +37,35 @@ describe('RetroReceiver', () => {
     ])
   })
 
-  describe('constructor', () => {
-    it('should set the owner', async () => {
-      expect(await RetroReceiver.owner()).to.equal(signer1.address)
-    })
-  })
-
   describe('receive', () => {
     it('should be able to receive ETH', async () => {
       await expect(
         signer1.sendTransaction({
-          to: RetroReceiver.address,
+          to: AssetReceiver.address,
           value: DEFAULT_AMOUNT,
         })
       ).to.not.be.reverted
 
       expect(
-        await hre.ethers.provider.getBalance(RetroReceiver.address)
+        await hre.ethers.provider.getBalance(AssetReceiver.address)
       ).to.equal(DEFAULT_AMOUNT)
     })
   })
 
   describe('withdrawETH(address)', () => {
-    describe('when called by the owner', () => {
+    describe('when called by authorized address', () => {
       it('should withdraw all ETH in the contract', async () => {
         await signer1.sendTransaction({
-          to: RetroReceiver.address,
+          to: AssetReceiver.address,
           value: DEFAULT_AMOUNT,
         })
 
-        await expect(RetroReceiver['withdrawETH(address)'](DEFAULT_RECIPIENT))
-          .to.emit(RetroReceiver, 'WithdrewETH')
+        await expect(AssetReceiver['withdrawETH(address)'](DEFAULT_RECIPIENT))
+          .to.emit(AssetReceiver, 'WithdrewETH')
           .withArgs(signer1.address, DEFAULT_RECIPIENT, DEFAULT_AMOUNT)
 
         expect(
-          await hre.ethers.provider.getBalance(RetroReceiver.address)
+          await hre.ethers.provider.getBalance(AssetReceiver.address)
         ).to.equal(0)
 
         expect(
@@ -80,36 +74,36 @@ describe('RetroReceiver', () => {
       })
     })
 
-    describe('when called by not the owner', () => {
+    describe('when called by not authorized address', () => {
       it('should revert', async () => {
         await expect(
-          RetroReceiver.connect(signer2)['withdrawETH(address)'](
+          AssetReceiver.connect(signer2)['withdrawETH(address)'](
             signer2.address
           )
-        ).to.be.revertedWith('UNAUTHORIZED')
+        ).to.be.revertedWith('Ownable: caller is not the owner')
       })
     })
   })
 
   describe('withdrawETH(address,uint256)', () => {
-    describe('when called by the owner', () => {
+    describe('when called by authorized address', () => {
       it('should withdraw the given amount of ETH', async () => {
         await signer1.sendTransaction({
-          to: RetroReceiver.address,
+          to: AssetReceiver.address,
           value: DEFAULT_AMOUNT.mul(2),
         })
 
         await expect(
-          RetroReceiver['withdrawETH(address,uint256)'](
+          AssetReceiver['withdrawETH(address,uint256)'](
             DEFAULT_RECIPIENT,
             DEFAULT_AMOUNT
           )
         )
-          .to.emit(RetroReceiver, 'WithdrewETH')
+          .to.emit(AssetReceiver, 'WithdrewETH')
           .withArgs(signer1.address, DEFAULT_RECIPIENT, DEFAULT_AMOUNT)
 
         expect(
-          await hre.ethers.provider.getBalance(RetroReceiver.address)
+          await hre.ethers.provider.getBalance(AssetReceiver.address)
         ).to.equal(DEFAULT_AMOUNT)
 
         expect(
@@ -118,30 +112,30 @@ describe('RetroReceiver', () => {
       })
     })
 
-    describe('when called by not the owner', () => {
+    describe('when called by not authorized address', () => {
       it('should revert', async () => {
         await expect(
-          RetroReceiver.connect(signer2)['withdrawETH(address,uint256)'](
+          AssetReceiver.connect(signer2)['withdrawETH(address,uint256)'](
             DEFAULT_RECIPIENT,
             DEFAULT_AMOUNT
           )
-        ).to.be.revertedWith('UNAUTHORIZED')
+        ).to.be.revertedWith('Ownable: caller is not the owner')
       })
     })
   })
 
   describe('withdrawERC20(address,address)', () => {
-    describe('when called by the owner', () => {
+    describe('when called by authorized address', () => {
       it('should withdraw all ERC20 balance held by the contract', async () => {
-        await TestERC20.transfer(RetroReceiver.address, DEFAULT_AMOUNT)
+        await TestERC20.transfer(AssetReceiver.address, DEFAULT_AMOUNT)
 
         await expect(
-          RetroReceiver['withdrawERC20(address,address)'](
+          AssetReceiver['withdrawERC20(address,address)'](
             TestERC20.address,
             DEFAULT_RECIPIENT
           )
         )
-          .to.emit(RetroReceiver, 'WithdrewERC20')
+          .to.emit(AssetReceiver, 'WithdrewERC20')
           .withArgs(
             signer1.address,
             DEFAULT_RECIPIENT,
@@ -155,31 +149,31 @@ describe('RetroReceiver', () => {
       })
     })
 
-    describe('when called by not the owner', () => {
+    describe('when called by not authorized address', () => {
       it('should revert', async () => {
         await expect(
-          RetroReceiver.connect(signer2)['withdrawERC20(address,address)'](
+          AssetReceiver.connect(signer2)['withdrawERC20(address,address)'](
             TestERC20.address,
             DEFAULT_RECIPIENT
           )
-        ).to.be.revertedWith('UNAUTHORIZED')
+        ).to.be.revertedWith('Ownable: caller is not the owner')
       })
     })
   })
 
   describe('withdrawERC20(address,address,uint256)', () => {
-    describe('when called by the owner', () => {
+    describe('when called by authorized address', () => {
       it('should withdraw the given ERC20 amount', async () => {
-        await TestERC20.transfer(RetroReceiver.address, DEFAULT_AMOUNT.mul(2))
+        await TestERC20.transfer(AssetReceiver.address, DEFAULT_AMOUNT.mul(2))
 
         await expect(
-          RetroReceiver['withdrawERC20(address,address,uint256)'](
+          AssetReceiver['withdrawERC20(address,address,uint256)'](
             TestERC20.address,
             DEFAULT_RECIPIENT,
             DEFAULT_AMOUNT
           )
         )
-          .to.emit(RetroReceiver, 'WithdrewERC20')
+          .to.emit(AssetReceiver, 'WithdrewERC20')
           .withArgs(
             signer1.address,
             DEFAULT_RECIPIENT,
@@ -193,34 +187,34 @@ describe('RetroReceiver', () => {
       })
     })
 
-    describe('when called by not the owner', () => {
+    describe('when called by not authorized address', () => {
       it('should revert', async () => {
         await expect(
-          RetroReceiver.connect(signer2)[
+          AssetReceiver.connect(signer2)[
             'withdrawERC20(address,address,uint256)'
           ](TestERC20.address, DEFAULT_RECIPIENT, DEFAULT_AMOUNT)
-        ).to.be.revertedWith('UNAUTHORIZED')
+        ).to.be.revertedWith('Ownable: caller is not the owner')
       })
     })
   })
 
   describe('withdrawERC721', () => {
-    describe('when called by the owner', () => {
+    describe('when called by authorized address', () => {
       it('should withdraw the token', async () => {
         await TestERC721.transferFrom(
           signer1.address,
-          RetroReceiver.address,
+          AssetReceiver.address,
           DEFAULT_TOKEN_ID
         )
 
         await expect(
-          RetroReceiver.withdrawERC721(
+          AssetReceiver.withdrawERC721(
             TestERC721.address,
             DEFAULT_RECIPIENT,
             DEFAULT_TOKEN_ID
           )
         )
-          .to.emit(RetroReceiver, 'WithdrewERC721')
+          .to.emit(AssetReceiver, 'WithdrewERC721')
           .withArgs(
             signer1.address,
             DEFAULT_RECIPIENT,
@@ -234,15 +228,15 @@ describe('RetroReceiver', () => {
       })
     })
 
-    describe('when called by not the owner', () => {
+    describe('when called by not authorized address', () => {
       it('should revert', async () => {
         await expect(
-          RetroReceiver.connect(signer2).withdrawERC721(
+          AssetReceiver.connect(signer2).withdrawERC721(
             TestERC721.address,
             DEFAULT_RECIPIENT,
             DEFAULT_TOKEN_ID
           )
-        ).to.be.revertedWith('UNAUTHORIZED')
+        ).to.be.revertedWith('Ownable: caller is not the owner')
       })
     })
   })

packages/contracts-periphery/test/contracts/universal/Transactor.spec.ts

+import hre from 'hardhat'
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers'
+import { Contract } from 'ethers'
+
+import { expect } from '../../setup'
+import { decodeSolidityRevert, deploy } from '../../helpers'
+
+describe('AssetReceiver', () => {
+  let signer1: SignerWithAddress
+  let signer2: SignerWithAddress
+  before('signer setup', async () => {
+    ;[signer1, signer2] = await hre.ethers.getSigners()
+  })
+
+  let CallRecorder: Contract
+  let Reverter: Contract
+  let Transactor: Contract
+  beforeEach('deploy contracts', async () => {
+    CallRecorder = await deploy('CallRecorder')
+    Reverter = await deploy('Reverter')
+    Transactor = await deploy('Transactor', {
+      signer: signer1,
+      args: [signer1.address],
+    })
+  })
+
+  describe('CALL', () => {
+    describe('when called by authorized address', () => {
+      it('should do a call to the target contract', async () => {
+        const data = CallRecorder.interface.encodeFunctionData('record')
+        await Transactor.CALL(CallRecorder.address, data, 1_000_000, 0, {
+          gasLimit: 2_000_000,
+        })
+
+        const call = await CallRecorder.lastCall()
+        expect(call.data).to.equal(data)
+        expect(call.sender).to.equal(Transactor.address)
+      })
+
+      it('should be able to call with value', async () => {
+        const data = CallRecorder.interface.encodeFunctionData('record')
+        const value = 69
+        await Transactor.CALL(CallRecorder.address, data, 1_000_000, value, {
+          gasLimit: 2_000_000,
+          value,
+        })
+
+        const call = await CallRecorder.lastCall()
+        expect(call.value).to.equal(value)
+      })
+
+      it('should be able to set gas limit', async () => {
+        const data = CallRecorder.interface.encodeFunctionData('record')
+        const gas = 100_000
+        await Transactor.CALL(CallRecorder.address, data, gas, 0, {
+          gasLimit: 2_000_000,
+        })
+
+        const call = await CallRecorder.lastCall()
+        expect(call.gas.toNumber()).to.be.lessThan(gas)
+      })
+    })
+
+    describe('when called by not authorized address', () => {
+      it('should be reverted', async () => {
+        const data = CallRecorder.interface.encodeFunctionData('record')
+        await expect(
+          Transactor.connect(signer2).CALL(
+            CallRecorder.address,
+            data,
+            1_000_000,
+            0,
+            {
+              gasLimit: 2_000_000,
+            }
+          )
+        ).to.be.revertedWith('Ownable: caller is not the owner')
+      })
+    })
+  })
+
+  describe('DELEGATECALL', () => {
+    describe('when called by authorized address', () => {
+      it('should do a delegatecall to the target contract', async () => {
+        const data = Reverter.interface.encodeFunctionData('doRevert')
+        const ret = await Transactor.callStatic.DELEGATECALL(
+          Reverter.address,
+          data,
+          1_000_000,
+          {
+            gasLimit: 2_000_000,
+          }
+        )
+
+        expect(ret[0]).to.equal(false)
+        expect(decodeSolidityRevert(ret[1])).to.deep.equal('Reverter reverted')
+      })
+    })
+
+    describe('when called by not authorized address', () => {
+      it('should be reverted', async () => {
+        const data = Reverter.interface.encodeFunctionData('doRevert')
+        await expect(
+          Transactor.connect(signer2).DELEGATECALL(
+            Reverter.address,
+            data,
+            1_000_000,
+            {
+              gasLimit: 2_000_000,
+            }
+          )
+        ).to.be.revertedWith('Ownable: caller is not the owner')
+      })
+    })
+  })
+})

packages/contracts-periphery/test/contracts/universal/drippie/Drippie.spec.ts

+import hre from 'hardhat'
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers'
+import { Contract } from 'ethers'
+import { toRpcHexString } from '@eth-optimism/core-utils'
+
+import { expect } from '../../../setup'
+import { deploy } from '../../../helpers'
+
+describe('Drippie', () => {
+  const DEFAULT_DRIP_NAME = 'drippity drip drip'
+  const DEFAULT_DRIP_CONFIG = {
+    interval: hre.ethers.BigNumber.from(100),
+    dripcheck: '', // Gets added in setup
+    checkparams: '0x',
+    actions: [
+      {
+        target: '0x' + '11'.repeat(20),
+        data: '0x',
+        value: hre.ethers.BigNumber.from(1),
+      },
+    ],
+  }
+
+  let signer1: SignerWithAddress
+  let signer2: SignerWithAddress
+  before('signer setup', async () => {
+    ;[signer1, signer2] = await hre.ethers.getSigners()
+  })
+
+  before('deploy default dripcheck', async () => {
+    DEFAULT_DRIP_CONFIG.dripcheck = (await deploy('CheckTrue')).address
+  })
+
+  let SimpleStorage: Contract
+  let Drippie: Contract
+  beforeEach('deploy contracts', async () => {
+    SimpleStorage = await deploy('SimpleStorage')
+    Drippie = await deploy('Drippie', {
+      signer: signer1,
+      args: [signer1.address],
+    })
+  })
+
+  beforeEach('balance setup', async () => {
+    await hre.ethers.provider.send('hardhat_setBalance', [
+      Drippie.address,
+      toRpcHexString(DEFAULT_DRIP_CONFIG.actions[0].value.mul(100000)),
+    ])
+    await hre.ethers.provider.send('hardhat_setBalance', [
+      DEFAULT_DRIP_CONFIG.actions[0].target,
+      '0x0',
+    ])
+  })
+
+  describe('create', () => {
+    describe('when called by authorized address', () => {
+      it('should create a drip with the given name', async () => {
+        await expect(
+          Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+        ).to.emit(Drippie, 'DripCreated')
+
+        const drip = await Drippie.drips(DEFAULT_DRIP_NAME)
+        expect(drip.status).to.equal(2) // PAUSED
+        expect(drip.last).to.deep.equal(hre.ethers.BigNumber.from(0))
+        expect(drip.config.interval).to.deep.equal(DEFAULT_DRIP_CONFIG.interval)
+        expect(drip.config.dripcheck).to.deep.equal(
+          DEFAULT_DRIP_CONFIG.dripcheck
+        )
+        expect(drip.config.checkparams).to.deep.equal(
+          DEFAULT_DRIP_CONFIG.checkparams
+        )
+        expect(drip.config.actions[0][0]).to.deep.equal(
+          DEFAULT_DRIP_CONFIG.actions[0].target
+        )
+        expect(drip.config.actions[0][1]).to.deep.equal(
+          DEFAULT_DRIP_CONFIG.actions[0].data
+        )
+        expect(drip.config.actions[0][2]).to.deep.equal(
+          DEFAULT_DRIP_CONFIG.actions[0].value
+        )
+      })
+
+      it('should not be able to create the same drip twice', async () => {
+        await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+
+        await expect(
+          Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+        ).to.be.revertedWith('Drippie: drip with that name already exists')
+      })
+    })
+
+    describe('when called by not authorized address', () => {
+      it('should revert', async () => {
+        await expect(
+          Drippie.connect(signer2).create(
+            DEFAULT_DRIP_NAME,
+            DEFAULT_DRIP_CONFIG
+          )
+        ).to.be.revertedWith('Ownable: caller is not the owner')
+      })
+    })
+  })
+
+  describe('status', () => {
+    describe('when called by authorized address', () => {
+      it('should allow setting between PAUSED and ACTIVE', async () => {
+        await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+
+        expect((await Drippie.drips(DEFAULT_DRIP_NAME)).status).to.equal(2) // PAUSED
+
+        await Drippie.status(DEFAULT_DRIP_NAME, 1) // ACTIVE
+
+        expect((await Drippie.drips(DEFAULT_DRIP_NAME)).status).to.equal(1) // ACTIVE
+
+        await Drippie.status(DEFAULT_DRIP_NAME, 2) // PAUSED
+
+        expect((await Drippie.drips(DEFAULT_DRIP_NAME)).status).to.equal(2) // PAUSED
+      })
+
+      it('should not allow setting status to NONE', async () => {
+        await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+
+        await expect(Drippie.status(DEFAULT_DRIP_NAME, 0)).to.be.revertedWith(
+          'Drippie: drip status can never be set back to NONE after creation'
+        )
+      })
+
+      it('should not allow setting status to same status as before', async () => {
+        await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+
+        await expect(Drippie.status(DEFAULT_DRIP_NAME, 2)).to.be.revertedWith(
+          'Drippie: cannot set drip status to same status as before'
+        )
+      })
+
+      it('should allow setting status to ARCHIVED if PAUSED', async () => {
+        await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+
+        await Drippie.status(DEFAULT_DRIP_NAME, 3) // ARCHIVED
+
+        expect((await Drippie.drips(DEFAULT_DRIP_NAME)).status).to.equal(3) // ARCHIVED
+      })
+
+      it('should not allow setting status to ARCHIVED if ACTIVE', async () => {
+        await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+
+        await Drippie.status(DEFAULT_DRIP_NAME, 1) // ACTIVE
+
+        await expect(Drippie.status(DEFAULT_DRIP_NAME, 3)).to.be.revertedWith(
+          'Drippie: drip must be paused to be archived'
+        )
+      })
+
+      it('should not allow setting status to PAUSED if ARCHIVED', async () => {
+        await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+
+        await Drippie.status(DEFAULT_DRIP_NAME, 3) // ARCHIVED
+
+        await expect(Drippie.status(DEFAULT_DRIP_NAME, 2)).to.be.revertedWith(
+          'Drippie: drip with that name has been archived'
+        )
+      })
+
+      it('should not allow setting status to ACTIVE if ARCHIVED', async () => {
+        await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+
+        await Drippie.status(DEFAULT_DRIP_NAME, 3) // ARCHIVED
+
+        await expect(Drippie.status(DEFAULT_DRIP_NAME, 1)).to.be.revertedWith(
+          'Drippie: drip with that name has been archived'
+        )
+      })
+
+      it('should revert if the drip does not exist yet', async () => {
+        await expect(Drippie.status(DEFAULT_DRIP_NAME, 1)).to.be.revertedWith(
+          'Drippie: drip with that name does not exist'
+        )
+      })
+    })
+
+    describe('when called by not authorized address', () => {
+      it('should revert', async () => {
+        await expect(
+          Drippie.connect(signer2).status(DEFAULT_DRIP_NAME, 1)
+        ).to.be.revertedWith('Ownable: caller is not the owner')
+      })
+    })
+  })
+
+  describe('drip', () => {
+    it('should drip the amount', async () => {
+      await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+      await Drippie.status(DEFAULT_DRIP_NAME, 1) // ACTIVE
+
+      await expect(Drippie.drip(DEFAULT_DRIP_NAME)).to.emit(
+        Drippie,
+        'DripExecuted'
+      )
+
+      expect(
+        await signer1.provider.getBalance(DEFAULT_DRIP_CONFIG.actions[0].target)
+      ).to.equal(DEFAULT_DRIP_CONFIG.actions[0].value)
+    })
+
+    it('should be able to trigger one function', async () => {
+      await Drippie.create(DEFAULT_DRIP_NAME, {
+        ...DEFAULT_DRIP_CONFIG,
+        actions: [
+          {
+            target: SimpleStorage.address,
+            data: SimpleStorage.interface.encodeFunctionData('set', [
+              '0x' + '33'.repeat(32),
+              '0x' + '44'.repeat(32),
+            ]),
+            value: hre.ethers.BigNumber.from(0),
+          },
+        ],
+      })
+
+      await Drippie.status(DEFAULT_DRIP_NAME, 1) // ACTIVE
+      await Drippie.drip(DEFAULT_DRIP_NAME)
+
+      expect(await SimpleStorage.get('0x' + '33'.repeat(32))).to.equal(
+        '0x' + '44'.repeat(32)
+      )
+    })
+
+    it('should be able to trigger two functions', async () => {
+      await Drippie.create(DEFAULT_DRIP_NAME, {
+        ...DEFAULT_DRIP_CONFIG,
+        actions: [
+          {
+            target: SimpleStorage.address,
+            data: SimpleStorage.interface.encodeFunctionData('set', [
+              '0x' + '33'.repeat(32),
+              '0x' + '44'.repeat(32),
+            ]),
+            value: hre.ethers.BigNumber.from(0),
+          },
+          {
+            target: SimpleStorage.address,
+            data: SimpleStorage.interface.encodeFunctionData('set', [
+              '0x' + '44'.repeat(32),
+              '0x' + '55'.repeat(32),
+            ]),
+            value: hre.ethers.BigNumber.from(0),
+          },
+        ],
+      })
+
+      await Drippie.status(DEFAULT_DRIP_NAME, 1) // ACTIVE
+      await Drippie.drip(DEFAULT_DRIP_NAME)
+
+      expect(await SimpleStorage.get('0x' + '33'.repeat(32))).to.equal(
+        '0x' + '44'.repeat(32)
+      )
+      expect(await SimpleStorage.get('0x' + '44'.repeat(32))).to.equal(
+        '0x' + '55'.repeat(32)
+      )
+    })
+
+    it('should revert if dripping twice in one interval', async () => {
+      await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+      await Drippie.status(DEFAULT_DRIP_NAME, 1) // ACTIVE
+      await Drippie.drip(DEFAULT_DRIP_NAME)
+
+      await expect(Drippie.drip(DEFAULT_DRIP_NAME)).to.be.revertedWith(
+        'Drippie: drip interval has not elapsed'
+      )
+
+      await hre.ethers.provider.send('evm_increaseTime', [
+        DEFAULT_DRIP_CONFIG.interval.add(1).toHexString(),
+      ])
+
+      await expect(Drippie.drip(DEFAULT_DRIP_NAME)).to.not.be.reverted
+    })
+
+    it('should revert when the drip does not exist', async () => {
+      await expect(Drippie.drip(DEFAULT_DRIP_NAME)).to.be.revertedWith(
+        'Drippie: selected drip does not exist or is not currently active'
+      )
+    })
+
+    it('should revert when the drip is not active', async () => {
+      await Drippie.create(DEFAULT_DRIP_NAME, DEFAULT_DRIP_CONFIG)
+
+      await expect(Drippie.drip(DEFAULT_DRIP_NAME)).to.be.revertedWith(
+        'Drippie: selected drip does not exist or is not currently active'
+      )
+    })
+  })
+})

packages/contracts-periphery/test/contracts/universal/drippie/dripchecks/CheckBalanceHigh.spec.ts

+import hre from 'hardhat'
+import { Contract } from 'ethers'
+import { toRpcHexString } from '@eth-optimism/core-utils'
+
+import { expect } from '../../../../setup'
+import { deploy } from '../../../../helpers'
+import { encodeDripCheckParams } from '../../../../../src'
+
+describe('CheckBalanceHigh', () => {
+  const RECIPIENT = '0x' + '11'.repeat(20)
+  const THRESHOLD = 100
+
+  let CheckBalanceHigh: Contract
+  before(async () => {
+    CheckBalanceHigh = await deploy('CheckBalanceHigh')
+  })
+
+  describe('check', () => {
+    it('should return true when balance is above threshold', async () => {
+      await hre.ethers.provider.send('hardhat_setBalance', [
+        RECIPIENT,
+        toRpcHexString(THRESHOLD + 1),
+      ])
+
+      expect(
+        await CheckBalanceHigh.check(
+          encodeDripCheckParams(CheckBalanceHigh.interface, {
+            target: RECIPIENT,
+            threshold: THRESHOLD,
+          })
+        )
+      ).to.equal(true)
+    })
+
+    it('should return false when balance is below threshold', async () => {
+      await hre.ethers.provider.send('hardhat_setBalance', [
+        RECIPIENT,
+        toRpcHexString(THRESHOLD - 1),
+      ])
+
+      expect(
+        await CheckBalanceHigh.check(
+          encodeDripCheckParams(CheckBalanceHigh.interface, {
+            target: RECIPIENT,
+            threshold: THRESHOLD,
+          })
+        )
+      ).to.equal(false)
+    })
+  })
+})

packages/contracts-periphery/test/contracts/universal/drippie/dripchecks/CheckBalanceLow.spec.ts

+import hre from 'hardhat'
+import { Contract } from 'ethers'
+import { toRpcHexString } from '@eth-optimism/core-utils'
+
+import { expect } from '../../../../setup'
+import { deploy } from '../../../../helpers'
+import { encodeDripCheckParams } from '../../../../../src'
+
+describe('CheckBalanceLow', () => {
+  const RECIPIENT = '0x' + '11'.repeat(20)
+  const THRESHOLD = 100
+
+  let CheckBalanceLow: Contract
+  before(async () => {
+    CheckBalanceLow = await deploy('CheckBalanceLow')
+  })
+
+  describe('check', () => {
+    it('should return true when balance is below threshold', async () => {
+      await hre.ethers.provider.send('hardhat_setBalance', [
+        RECIPIENT,
+        toRpcHexString(THRESHOLD - 1),
+      ])
+
+      expect(
+        await CheckBalanceLow.check(
+          encodeDripCheckParams(CheckBalanceLow.interface, {
+            target: RECIPIENT,
+            threshold: THRESHOLD,
+          })
+        )
+      ).to.equal(true)
+    })
+
+    it('should return false when balance is above threshold', async () => {
+      await hre.ethers.provider.send('hardhat_setBalance', [
+        RECIPIENT,
+        toRpcHexString(THRESHOLD + 1),
+      ])
+
+      expect(
+        await CheckBalanceLow.check(
+          encodeDripCheckParams(CheckBalanceLow.interface, {
+            target: RECIPIENT,
+            threshold: THRESHOLD,
+          })
+        )
+      ).to.equal(false)
+    })
+  })
+})

packages/contracts-periphery/test/contracts/universal/drippie/dripchecks/CheckGelatoLow.spec.ts

+import { Contract } from 'ethers'
+import { smock, FakeContract } from '@defi-wonderland/smock'
+
+import { expect } from '../../../../setup'
+import { deploy } from '../../../../helpers'
+import { encodeDripCheckParams } from '../../../../../src'
+
+describe('CheckGelatoLow', () => {
+  const RECIPIENT = '0x' + '11'.repeat(20)
+  const THRESHOLD = 100
+
+  let CheckGelatoLow: Contract
+  let FakeGelatoTresury: FakeContract<Contract>
+  before(async () => {
+    CheckGelatoLow = await deploy('CheckGelatoLow')
+    FakeGelatoTresury = await smock.fake('IGelatoTreasury')
+  })
+
+  describe('check', () => {
+    it('should return true when balance is below threshold', async () => {
+      FakeGelatoTresury.userTokenBalance.returns(THRESHOLD - 1)
+
+      expect(
+        await CheckGelatoLow.check(
+          encodeDripCheckParams(CheckGelatoLow.interface, {
+            treasury: FakeGelatoTresury.address,
+            threshold: THRESHOLD,
+            recipient: RECIPIENT,
+          })
+        )
+      ).to.equal(true)
+    })
+
+    it('should return false when balance is above threshold', async () => {
+      FakeGelatoTresury.userTokenBalance.returns(THRESHOLD + 1)
+
+      expect(
+        await CheckGelatoLow.check(
+          encodeDripCheckParams(CheckGelatoLow.interface, {
+            treasury: FakeGelatoTresury.address,
+            threshold: THRESHOLD,
+            recipient: RECIPIENT,
+          })
+        )
+      ).to.equal(false)
+    })
+  })
+})

packages/contracts-periphery/test/contracts/universal/drippie/dripchecks/CheckTrue.spec.ts

+import { Contract } from 'ethers'
+
+import { expect } from '../../../../setup'
+import { deploy } from '../../../../helpers'
+
+describe('CheckTrue', () => {
+  let CheckTrue: Contract
+  before(async () => {
+    CheckTrue = await deploy('CheckTrue')
+  })
+
+  describe('check', () => {
+    it('should return true', async () => {
+      expect(await CheckTrue.check('0x')).to.equal(true)
+    })
+  })
+})

packages/contracts-periphery/test/helpers/index.ts

 export * from './deploy'
+export * from './solidity'

packages/contracts-periphery/test/helpers/solidity.ts

+import { ethers } from 'ethers'
+
+export const decodeSolidityRevert = (revert: string) => {
+  const iface = new ethers.utils.Interface([
+    {
+      inputs: [
+        {
+          internalType: 'string',
+          name: 'message',
+          type: 'string',
+        },
+      ],
+      name: 'Error',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    },
+  ])
+
+  return iface.decodeFunctionData('Error', revert)[0]
+}