Remove logic for connecting contracts which was never used

packages/contracts/src/connect-contracts.ts

-import { Signer, Contract } from 'ethers'
-import { Provider } from '@ethersproject/abstract-provider'
-import { getContractArtifact } from './contract-artifacts'
-import { getDeployedContractArtifact } from './contract-deployed-artifacts'
-import { predeploys } from './predeploys'
-
-export type Network = 'goerli' | 'kovan' | 'mainnet'
-interface L1Contracts {
-  addressManager: Contract
-  canonicalTransactionChain: Contract
-  stateCommitmentChain: Contract
-  xDomainMessengerProxy: Contract
-  bondManager: Contract
-}
-
-interface L2Contracts {
-  eth: Contract
-  xDomainMessenger: Contract
-  messagePasser: Contract
-  deployerWhiteList: Contract
-}
-
-/**
- * Validates user provided a singer or provider & throws error if not
- *
- * @param signerOrProvider
- */
-const checkSignerType = (signerOrProvider: Signer | Provider) => {
-  if (!signerOrProvider) {
-    throw Error('signerOrProvider argument is undefined')
-  }
-  if (
-    !Provider.isProvider(signerOrProvider) &&
-    !Signer.isSigner(signerOrProvider)
-  ) {
-    throw Error('signerOrProvider argument is the wrong type')
-  }
-}
-
-/**
- * Connects a signer/provider to layer 1 contracts on a given network
- *
- * @param signerOrProvider ethers signer or provider
- * @param network string denoting network
- * @returns l1 contracts connected to signer/provider
- */
-export const connectL1Contracts = async (
-  signerOrProvider: Signer | Provider,
-  network: Network
-): Promise<L1Contracts> => {
-  checkSignerType(signerOrProvider)
-
-  if (!['mainnet', 'kovan', 'goerli'].includes(network)) {
-    throw Error('Must specify network: mainnet, kovan, or goerli.')
-  }
-
-  const getEthersContract = (name: string) => {
-    const artifact = getDeployedContractArtifact(name, network)
-    return new Contract(artifact.address, artifact.abi, signerOrProvider)
-  }
-
-  return {
-    addressManager: getEthersContract('Lib_AddressManager'),
-    canonicalTransactionChain: getEthersContract('CanonicalTransactionChain'),
-    stateCommitmentChain: getEthersContract('StateCommitmentChain'),
-    xDomainMessengerProxy: getEthersContract('Proxy__L1CrossDomainMessenger'),
-    bondManager: getEthersContract('mockBondManager'),
-  }
-}
-
-/**
- * Connects a signer/provider to layer 2 contracts (network agnostic)
- *
- * @param signerOrProvider ethers signer or provider
- * @returns l2 contracts connected to signer/provider
- */
-export const connectL2Contracts = async (
-  signerOrProvider: any
-): Promise<L2Contracts> => {
-  checkSignerType(signerOrProvider)
-
-  const getEthersContract = (name: string, iface?: string) => {
-    const artifact = getContractArtifact(iface || name)
-    const address = predeploys[name]
-    return new Contract(address, artifact.abi, signerOrProvider)
-  }
-
-  return {
-    eth: getEthersContract('OVM_ETH'),
-    xDomainMessenger: getEthersContract('L2CrossDomainMessenger'),
-    messagePasser: getEthersContract('OVM_L2ToL1MessagePasser'),
-    deployerWhiteList: getEthersContract('OVM_DeployerWhitelist'),
-  }
-}

packages/contracts/src/contract-data.ts

-/* eslint-disable @typescript-eslint/no-var-requires */
-import { predeploys as l2Addresses } from './predeploys'
-import { Network } from './connect-contracts'
-
-/**
- * This file is necessarily not DRY because it needs to be usable
- * in a browser context and can't take advantage of dynamic imports
- * (ie: the json needs to all be imported when transpiled)
- */
-
-const Mainnet__Lib_AddressManager = require('../deployments/mainnet/Lib_AddressManager.json')
-const Mainnet__CanonicalTransactionChain = require('../deployments/mainnet/CanonicalTransactionChain.json')
-const Mainnet__L1CrossDomainMessenger = require('../deployments/mainnet/L1CrossDomainMessenger.json')
-const Mainnet__StateCommitmentChain = require('../deployments/mainnet/StateCommitmentChain.json')
-const Mainnet__Proxy__L1CrossDomainMessenger = require('../deployments/mainnet/Proxy__L1CrossDomainMessenger.json')
-const Mainnet__BondManager = require('../deployments/mainnet/mockBondManager.json')
-
-const Kovan__Lib_AddressManager = require('../deployments/kovan/Lib_AddressManager.json')
-const Kovan__CanonicalTransactionChain = require('../deployments/kovan/CanonicalTransactionChain.json')
-const Kovan__L1CrossDomainMessenger = require('../deployments/kovan/L1CrossDomainMessenger.json')
-const Kovan__StateCommitmentChain = require('../deployments/kovan/StateCommitmentChain.json')
-const Kovan__Proxy__L1CrossDomainMessenger = require('../deployments/kovan/Proxy__L1CrossDomainMessenger.json')
-const Kovan__BondManager = require('../deployments/kovan/mockBondManager.json')
-
-const Goerli__Lib_AddressManager = require('../deployments/goerli/Lib_AddressManager.json')
-const Goerli__CanonicalTransactionChain = require('../deployments/goerli/CanonicalTransactionChain.json')
-const Goerli__L1CrossDomainMessenger = require('../deployments/goerli/L1CrossDomainMessenger.json')
-const Goerli__StateCommitmentChain = require('../deployments/goerli/StateCommitmentChain.json')
-const Goerli__Proxy__L1CrossDomainMessenger = require('../deployments/goerli/Proxy__L1CrossDomainMessenger.json')
-const Goerli__BondManager = require('../deployments/goerli/mockBondManager.json')
-
-export const getL1ContractData = (network: Network) => {
-  return {
-    Lib_AddressManager: {
-      mainnet: Mainnet__Lib_AddressManager,
-      kovan: Kovan__Lib_AddressManager,
-      goerli: Goerli__Lib_AddressManager,
-    }[network],
-    CanonicalTransactionChain: {
-      mainnet: Mainnet__CanonicalTransactionChain,
-      kovan: Kovan__CanonicalTransactionChain,
-      goerli: Goerli__CanonicalTransactionChain,
-    }[network],
-    L1CrossDomainMessenger: {
-      mainnet: Mainnet__L1CrossDomainMessenger,
-      kovan: Kovan__L1CrossDomainMessenger,
-      goerli: Goerli__L1CrossDomainMessenger,
-    }[network],
-    StateCommitmentChain: {
-      mainnet: Mainnet__StateCommitmentChain,
-      kovan: Kovan__StateCommitmentChain,
-      goerli: Goerli__StateCommitmentChain,
-    }[network],
-    Proxy__L1CrossDomainMessenger: {
-      mainnet: Mainnet__Proxy__L1CrossDomainMessenger,
-      kovan: Kovan__Proxy__L1CrossDomainMessenger,
-      goerli: Goerli__Proxy__L1CrossDomainMessenger,
-    }[network],
-    BondManager: {
-      mainnet: Mainnet__BondManager,
-      kovan: Kovan__BondManager,
-      goerli: Goerli__BondManager,
-    }[network],
-  }
-}
-
-const OVM_ETH = require('../artifacts/contracts/L2/predeploys/OVM_ETH.sol/OVM_ETH.json')
-const L2CrossDomainMessenger = require('../artifacts/contracts/L2/messaging/L2CrossDomainMessenger.sol/L2CrossDomainMessenger.json')
-const OVM_L2ToL1MessagePasser = require('../artifacts/contracts/L2/predeploys/OVM_L2ToL1MessagePasser.sol/OVM_L2ToL1MessagePasser.json')
-const OVM_DeployerWhitelist = require('../artifacts/contracts/L2/predeploys/OVM_DeployerWhitelist.sol/OVM_DeployerWhitelist.json')
-
-export const getL2ContractData = () => {
-  return {
-    OVM_ETH: {
-      abi: OVM_ETH.abi,
-      address: l2Addresses.OVM_ETH,
-    },
-    L2CrossDomainMessenger: {
-      abi: L2CrossDomainMessenger.abi,
-      address: l2Addresses.L2CrossDomainMessenger,
-    },
-    OVM_L2ToL1MessagePasser: {
-      abi: OVM_L2ToL1MessagePasser.abi,
-      address: l2Addresses.OVM_L2ToL1MessagePasser,
-    },
-    OVM_DeployerWhitelist: {
-      abi: OVM_DeployerWhitelist.abi,
-      address: l2Addresses.OVM_DeployerWhitelist,
-    },
-  }
-}

packages/contracts/src/index.ts

 export * from './contract-defs'
 export * from './predeploys'
-export * from './connect-contracts'

packages/contracts/test/connect-contracts.spec.ts

-import { ethers } from 'hardhat'
-import { Signer, Contract } from 'ethers'
-import {
-  connectL1Contracts,
-  connectL2Contracts,
-} from '../dist/connect-contracts'
-import { expect } from './setup'
-
-// Skipping these tests as the FE work that relies on this logic was never finished.
-// Dedicated issue created in https://linear.app/optimism/issue/ENG-1451/decide-what-to-do-with-the-connectl1contracts-tests
-describe.skip('connectL1Contracts', () => {
-  let user: Signer
-  const l1ContractNames = [
-    'addressManager',
-    'canonicalTransactionChain',
-    'stateCommitmentChain',
-    'xDomainMessengerProxy',
-    'bondManager',
-  ]
-
-  const l2ContractNames = [
-    'eth',
-    'xDomainMessenger',
-    'messagePasser',
-    'messageSender',
-    'deployerWhiteList',
-  ]
-
-  before(async () => {
-    ;[user] = await ethers.getSigners()
-  })
-
-  it(`connectL1Contracts should throw error if signer or provider isn't provided.`, async () => {
-    try {
-      await connectL1Contracts(undefined, 'mainnet')
-    } catch (err) {
-      expect(err.message).to.be.equal('signerOrProvider argument is undefined')
-    }
-  })
-
-  for (const name of l1ContractNames) {
-    it(`connectL1Contracts should return a contract assigned to a field named "${name}"`, async () => {
-      const l1Contracts = await connectL1Contracts(user, 'mainnet')
-      expect(l1Contracts[name]).to.be.an.instanceOf(Contract)
-    })
-  }
-
-  for (const name of l2ContractNames) {
-    it(`connectL2Contracts should return a contract assigned to a field named "${name}"`, async () => {
-      const l2Contracts = await connectL2Contracts(user)
-      expect(l2Contracts[name]).to.be.an.instanceOf(Contract)
-    })
-  }
-})