@openzeppelin/upgrades-core 1.12.0 → 1.13.0

package/src/deployment.ts

@@ -4,13 +4,16 @@ import debug from './utils/debug';
 import { makeNonEnumerable } from './utils/make-non-enumerable';
 import {
   EthereumProvider,
+  getCode,
   getTransactionByHash,
   getTransactionReceipt,
   hasCode,
   isDevelopmentNetwork,
+  isEmpty,
   isReceiptSuccessful,
 } from './provider';
 import { UpgradesError } from './error';
+import { deleteDeployment, ManifestField } from './impl-store';
 
 const sleep = promisify(setTimeout);
 
@@ -31,37 +34,101 @@ export interface DeployOpts {
   pollingInterval?: number;
 }
 
+/**
+ * Resumes a deployment or deploys a new one, based on whether the cached deployment should continue to be used and is valid
+ * (has a valid txHash for the current network or has runtime bytecode).
+ * If a cached deployment is not valid, deletes it if using a development network, otherwise throws an InvalidDeployment error.
+ *
+ * @param provider the Ethereum provider
+ * @param cached the cached deployment
+ * @param deploy the function to deploy a new deployment if needed
+ * @param type the manifest lens type. If merge is true, used for the timeout message if a previous deployment is not
+ *   confirmed within the timeout period. Otherwise not used.
+ * @param opts polling timeout and interval options. If merge is true, used to check a previous deployment for confirmation.
+ *   Otherwise not used.
+ * @param deployment the manifest field for this deployment. Optional for backward compatibility.
+ *   If not provided, invalid deployments will not be deleted in a dev network (which is not a problem if merge is false,
+ *   since it will be overwritten with the new deployment).
+ * @param merge whether the cached deployment is intended to be merged with the new deployment. Defaults to false.
+ * @returns the cached deployment if it should be used, otherwise the new deployment from the deploy function
+ * @throws {InvalidDeployment} if the cached deployment is invalid and we are not on a dev network
+ */
 export async function resumeOrDeploy<T extends Deployment>(
   provider: EthereumProvider,
   cached: T | undefined,
   deploy: () => Promise<T>,
+  type?: string,
+  opts?: DeployOpts,
+  deployment?: ManifestField<T>,
+  merge?: boolean,
 ): Promise<T> {
+  const validated = await validateCached(cached, provider, type, opts, deployment, merge);
+  if (validated === undefined || merge) {
+    const deployment = await deploy();
+    debug('initiated deployment', 'transaction hash:', deployment.txHash, 'merge:', merge);
+    return deployment;
+  } else {
+    return validated;
+  }
+}
+
+async function validateCached<T extends Deployment>(
+  cached: T | undefined,
+  provider: EthereumProvider,
+  type?: string,
+  opts?: DeployOpts,
+  deployment?: ManifestField<T>,
+  merge?: boolean,
+): Promise<T | undefined> {
   if (cached !== undefined) {
-    const { txHash } = cached;
-    if (txHash === undefined) {
-      // Nothing to do here without a txHash.
-      // This is the case for deployments migrated from OpenZeppelin CLI.
-      return cached;
+    try {
+      await validateStoredDeployment(cached, provider, type, opts, merge);
+    } catch (e) {
+      if (e instanceof InvalidDeployment && (await isDevelopmentNetwork(provider))) {
+        debug('ignoring invalid deployment in development network', e.deployment.address);
+        if (deployment !== undefined) {
+          deleteDeployment(deployment);
+        }
+        return undefined;
+      } else {
+        throw e;
+      }
     }
+  }
+  return cached;
+}
+
+async function validateStoredDeployment<T extends Deployment>(
+  stored: T,
+  provider: EthereumProvider,
+  type?: string,
+  opts?: DeployOpts,
+  merge?: boolean,
+) {
+  const { txHash } = stored;
+  if (txHash !== undefined) {
     // If there is a deployment with txHash stored, we look its transaction up. If the
     // transaction is found, the deployment is reused.
     debug('found previous deployment', txHash);
     const tx = await getTransactionByHash(provider, txHash);
     if (tx !== null) {
       debug('resuming previous deployment', txHash);
-      return cached;
-    } else if (!(await isDevelopmentNetwork(provider))) {
+      if (merge) {
+        // If merging, wait for the existing deployment to be mined
+        waitAndValidateDeployment(provider, stored, type, opts);
+      }
+    } else {
       // If the transaction is not found we throw an error, except if we're in
       // a development network then we simply silently redeploy.
-      throw new InvalidDeployment(cached);
-    } else {
-      debug('ignoring invalid deployment in development network', txHash);
+      // This error should be caught by the caller to determine if we're in a dev network.
+      throw new InvalidDeployment(stored);
+    }
+  } else {
+    const existingBytecode = await getCode(provider, stored.address);
+    if (isEmpty(existingBytecode)) {
+      throw new InvalidDeployment(stored);
     }
   }
-
-  const deployment = await deploy();
-  debug('initiated deployment', deployment.txHash);
-  return deployment;
 }
 
 export async function waitAndValidateDeployment(

package/src/eip-1967-type.ts

@@ -1,8 +1,10 @@
 import {
   EIP1967BeaconNotFound,
   EIP1967ImplementationNotFound,
+  getAdminAddress,
   getBeaconAddress,
   getImplementationAddress,
+  isEmptySlot,
 } from './eip-1967';
 import { EthereumProvider } from './provider';
 
@@ -20,6 +22,11 @@ export async function isTransparentOrUUPSProxy(provider: EthereumProvider, addre
   }
 }
 
+export async function isTransparentProxy(provider: EthereumProvider, address: string): Promise<boolean> {
+  const adminAddress = await getAdminAddress(provider, address);
+  return !isEmptySlot(adminAddress);
+}
+
 export async function isBeaconProxy(provider: EthereumProvider, address: string): Promise<boolean> {
   try {
     await getBeaconAddress(provider, address);

package/src/eip-1967.ts

@@ -5,7 +5,6 @@ import { EthereumProvider, getStorageAt } from './provider';
 import { parseAddress } from './utils/address';
 
 export class EIP1967ImplementationNotFound extends UpgradesError {}
-
 export class EIP1967BeaconNotFound extends UpgradesError {}
 
 export async function getAdminAddress(provider: EthereumProvider, address: string): Promise<string> {
@@ -28,7 +27,9 @@ export async function getImplementationAddress(provider: EthereumProvider, addre
   );
 
   if (isEmptySlot(storage)) {
-    throw new EIP1967ImplementationNotFound(`Contract at ${address} doesn't look like an administered ERC 1967 proxy`);
+    throw new EIP1967ImplementationNotFound(
+      `Contract at ${address} doesn't look like an ERC 1967 proxy with a logic contract address`,
+    );
   }
 
   return parseAddressFromStorage(storage);
@@ -67,7 +68,7 @@ export function toEip1967Hash(label: string): string {
   return '0x' + bigNumber.toString(16);
 }
 
-function isEmptySlot(storage: string): boolean {
+export function isEmptySlot(storage: string): boolean {
   storage = storage.replace(/^0x/, '');
   return new BN(storage, 'hex').isZero();
 }

package/src/impl-address.ts

@@ -34,7 +34,7 @@ export async function getImplementationAddressFromBeacon(
       !(
         e.message.includes('function selector was not recognized') ||
         e.message.includes('invalid opcode') ||
-        e.message.includes('reverted')
+        e.message.includes('revert')
       )
     ) {
       throw e;

package/src/impl-store.test.ts

@@ -6,9 +6,10 @@ import util from 'util';
 import path from 'path';
 import os from 'os';
 
-import { fetchOrDeploy } from './impl-store';
+import { fetchOrDeploy, mergeAddresses } from './impl-store';
 import { getVersion } from './version';
 import { stubProvider } from './stub-provider';
+import { ImplDeployment } from './manifest';
 
 const rimraf = util.promisify(rimrafAsync);
 
@@ -57,3 +58,34 @@ test('cleans up invalid deployment', async t => {
   // the failed deployment has been cleaned up
   await fetchOrDeploy(version1, provider2, provider2.deploy);
 });
+
+test('merge addresses', async t => {
+  const depl1 = { address: '0x1' } as ImplDeployment;
+  const depl2 = { address: '0x2' } as ImplDeployment;
+
+  const { address, allAddresses } = await mergeAddresses(depl1, depl2);
+  t.is(address, '0x1');
+  t.true(unorderedEqual(allAddresses, ['0x1', '0x2']), allAddresses.toString());
+});
+
+test('merge multiple existing addresses', async t => {
+  const depl1 = { address: '0x1', allAddresses: ['0x1a', '0x1b'] } as ImplDeployment;
+  const depl2 = { address: '0x2' } as ImplDeployment;
+
+  const { address, allAddresses } = await mergeAddresses(depl1, depl2);
+  t.is(address, '0x1');
+  t.true(unorderedEqual(allAddresses, ['0x1', '0x1a', '0x1b', '0x2']), allAddresses.toString());
+});
+
+test('merge all addresses', async t => {
+  const depl1 = { address: '0x1', allAddresses: ['0x1a', '0x1b'] } as ImplDeployment;
+  const depl2 = { address: '0x2', allAddresses: ['0x2a', '0x2b'] } as ImplDeployment;
+
+  const { address, allAddresses } = await mergeAddresses(depl1, depl2);
+  t.is(address, '0x1');
+  t.true(unorderedEqual(allAddresses, ['0x1', '0x1a', '0x1b', '0x2', '0x2a', '0x2b']), allAddresses.toString());
+});
+
+function unorderedEqual(arr1: string[], arr2: string[]) {
+  return arr1.every(i => arr2.includes(i)) && arr2.every(i => arr1.includes(i));
+}

package/src/impl-store.ts

@@ -2,7 +2,7 @@ import debug from './utils/debug';
 import { Manifest, ManifestData, ImplDeployment } from './manifest';
 import { EthereumProvider, isDevelopmentNetwork } from './provider';
 import { Deployment, InvalidDeployment, resumeOrDeploy, waitAndValidateDeployment } from './deployment';
-import type { Version } from './version';
+import { Version } from './version';
 import assert from 'assert';
 import { DeployOpts } from '.';
 
@@ -12,9 +12,10 @@ interface ManifestLens<T> {
   (data: ManifestData): ManifestField<T>;
 }
 
-interface ManifestField<T> {
+export interface ManifestField<T> {
   get(): T | undefined;
   set(value: T | undefined): void;
+  merge?(value: T | undefined): void;
 }
 
 /**
@@ -24,6 +25,7 @@ interface ManifestField<T> {
  * @param provider the Ethereum provider
  * @param deploy the deploy function
  * @param opts options containing the timeout and pollingInterval parameters. If undefined, assumes the timeout is not configurable and will not mention those parameters in the error message for TransactionMinedTimeout.
+ * @param merge if true, adds a deployment to existing deployment by merging their addresses. Defaults to false.
  * @returns the deployment address
  * @throws {InvalidDeployment} if the deployment is invalid
  * @throws {TransactionMinedTimeout} if the transaction was not confirmed within the timeout period
@@ -33,6 +35,7 @@ async function fetchOrDeployGeneric<T extends Deployment>(
   provider: EthereumProvider,
   deploy: () => Promise<T>,
   opts?: DeployOpts,
+  merge?: boolean,
 ): Promise<string> {
   const manifest = await Manifest.forNetwork(provider);
 
@@ -41,14 +44,24 @@ async function fetchOrDeployGeneric<T extends Deployment>(
       debug('fetching deployment of', lens.description);
       const data = await manifest.read();
       const deployment = lens(data);
-      const stored = deployment.get();
-      if (stored === undefined) {
-        debug('deployment of', lens.description, 'not found');
+      if (merge && !deployment.merge) {
+        throw new Error(
+          'fetchOrDeployGeneric was called with merge set to true but the deployment lens does not have a merge function',
+        );
       }
-      const updated = await resumeOrDeploy(provider, stored, deploy);
+
+      const stored = deployment.get();
+      const updated = await resumeOrDeploy(provider, stored, deploy, lens.type, opts, deployment, merge);
       if (updated !== stored) {
-        await checkForAddressClash(provider, data, updated);
-        deployment.set(updated);
+        if (merge && deployment.merge) {
+          // only check primary addresses for clashes, since the address could already exist in an allAddresses field
+          // but the above updated and stored objects are different instances representing the same entry
+          await checkForAddressClash(provider, data, updated, false);
+          deployment.merge(updated);
+        } else {
+          await checkForAddressClash(provider, data, updated, true);
+          deployment.set(updated);
+        }
         await manifest.write(data);
       }
       return updated;
@@ -77,21 +90,57 @@ async function fetchOrDeployGeneric<T extends Deployment>(
   }
 }
 
+/**
+ * Deletes the deployment by setting it to undefined.
+ * Should only be used during a manifest run.
+ */
+export function deleteDeployment(deployment: ManifestField<Deployment>) {
+  deployment.set(undefined);
+}
+
 export async function fetchOrDeploy(
   version: Version,
   provider: EthereumProvider,
   deploy: () => Promise<ImplDeployment>,
   opts?: DeployOpts,
+  merge?: boolean,
 ): Promise<string> {
-  return fetchOrDeployGeneric(implLens(version.linkedWithoutMetadata), provider, deploy, opts);
+  return fetchOrDeployGeneric(implLens(version.linkedWithoutMetadata), provider, deploy, opts, merge);
 }
 
 const implLens = (versionWithoutMetadata: string) =>
   lens(`implementation ${versionWithoutMetadata}`, 'implementation', data => ({
     get: () => data.impls[versionWithoutMetadata],
     set: (value?: ImplDeployment) => (data.impls[versionWithoutMetadata] = value),
+    merge: (value?: ImplDeployment) => {
+      const existing = data.impls[versionWithoutMetadata];
+      if (existing !== undefined && value !== undefined) {
+        const { address, allAddresses } = mergeAddresses(existing, value);
+        data.impls[versionWithoutMetadata] = { ...existing, address, allAddresses };
+      } else {
+        data.impls[versionWithoutMetadata] = value;
+      }
+    },
   }));
 
+/**
+ * Merge the addresses in the deployments and returns them.
+ *
+ * @param existing existing deployment
+ * @param value deployment to add
+ */
+export function mergeAddresses(existing: ImplDeployment, value: ImplDeployment) {
+  const merged = new Set<string>();
+
+  merged.add(existing.address);
+  merged.add(value.address);
+
+  existing.allAddresses?.forEach(item => merged.add(item));
+  value.allAddresses?.forEach(item => merged.add(item));
+
+  return { address: existing.address, allAddresses: Array.from(merged) };
+}
+
 export async function fetchOrDeployAdmin(
   provider: EthereumProvider,
   deploy: () => Promise<Deployment>,
@@ -113,8 +162,9 @@ async function checkForAddressClash(
   provider: EthereumProvider,
   data: ManifestData,
   updated: Deployment,
+  checkAllAddresses: boolean,
 ): Promise<void> {
-  const clash = lookupDeployment(data, updated.address);
+  const clash = lookupDeployment(data, updated.address, checkAllAddresses);
   if (clash !== undefined) {
     if (await isDevelopmentNetwork(provider)) {
       debug('deleting a previous deployment at address', updated.address);
@@ -129,13 +179,20 @@ async function checkForAddressClash(
   }
 }
 
-function lookupDeployment(data: ManifestData, address: string): ManifestField<Deployment> | undefined {
+function lookupDeployment(
+  data: ManifestData,
+  address: string,
+  checkAllAddresses: boolean,
+): ManifestField<Deployment> | undefined {
   if (data.admin?.address === address) {
     return adminLens(data);
   }
 
   for (const versionWithoutMetadata in data.impls) {
-    if (data.impls[versionWithoutMetadata]?.address === address) {
+    if (
+      data.impls[versionWithoutMetadata]?.address === address ||
+      (checkAllAddresses && data.impls[versionWithoutMetadata]?.allAddresses?.includes(address))
+    ) {
       return implLens(versionWithoutMetadata)(data);
     }
   }

package/src/index.ts

@@ -1,9 +1,16 @@
 export * from './validate';
-export * from './impl-store';
+export { fetchOrDeploy, fetchOrDeployAdmin } from './impl-store';
 export * from './version';
-export * from './manifest';
 export * from './storage';
-export * from './eip-1967';
+export {
+  EIP1967BeaconNotFound,
+  EIP1967ImplementationNotFound,
+  getAdminAddress,
+  getBeaconAddress,
+  getImplementationAddress,
+  toEip1967Hash,
+  toFallbackEip1967Hash,
+} from './eip-1967';
 export * from './provider';
 export * from './src-decoder';
 export * from './solc-api';
@@ -11,18 +18,28 @@ export * from './deployment';
 export * from './link-refs';
 export * from './error';
 
+export {
+  ManifestData,
+  ImplDeployment,
+  ProxyDeployment,
+  Manifest,
+  migrateManifest,
+  DeploymentNotFound,
+} from './manifest';
+
 export { getStorageLayoutForAddress } from './manifest-storage-layout';
 
 export * from './scripts/migrate-oz-cli-project';
 
 export { logWarning } from './utils/log';
-export { setProxyKind, processProxyKind } from './proxy-kind';
+export { setProxyKind, processProxyKind, detectProxyKind } from './proxy-kind';
 
 export { UpgradeableContract } from './standalone';
 
 export { isTransparentOrUUPSProxy, isBeaconProxy } from './eip-1967-type';
 export { getImplementationAddressFromBeacon, getImplementationAddressFromProxy } from './impl-address';
 export { isBeacon } from './beacon';
+export { addProxyToManifest } from './add-proxy-to-manifest';
 
 export {
   BeaconProxyUnsupportedError,
@@ -31,5 +48,6 @@ export {
   DeployBeaconProxyUnsupportedError,
   DeployBeaconProxyImplUnknownError,
   DeployBeaconProxyKindError,
+  ForceImportUnsupportedError,
   assertNotProxy,
 } from './usage-error';

package/src/manifest-storage-layout.test.ts

@@ -1,4 +1,4 @@
-import _test, { TestInterface } from 'ava';
+import _test, { TestFn } from 'ava';
 import assert from 'assert';
 
 import { artifacts } from 'hardhat';
@@ -17,7 +17,7 @@ interface Context {
   validationData: ValidationData;
 }
 
-const test = _test as TestInterface<Context>;
+const test = _test as TestFn<Context>;
 
 test.before(async t => {
   const buildInfo = await artifacts.getBuildInfo('contracts/test/ManifestMigrate.sol:ManifestMigrateUnique');
@@ -44,6 +44,7 @@ test('getStorageLayoutForAddress - update layout', async t => {
     },
     proxies: [],
   });
+
   const layout = await getStorageLayoutForAddress(manifest, t.context.validationData, address);
   t.deepEqual(layout, updatedLayout);
   t.like(manifest.data, {

package/src/manifest-storage-layout.ts

@@ -5,6 +5,7 @@ import { ValidationData } from './validate/data';
 import { findVersionWithoutMetadataMatches, unfoldStorageLayout } from './validate/query';
 import { stabilizeTypeIdentifier } from './utils/type-id';
 import { DeepArray, deepEqual } from './utils/deep-array';
+import { UpgradesError } from './error';
 
 export async function getStorageLayoutForAddress(
   manifest: Manifest,
@@ -12,13 +13,17 @@ export async function getStorageLayoutForAddress(
   implAddress: string,
 ): Promise<StorageLayout> {
   const data = await manifest.read();
-  const versionWithoutMetadata = Object.keys(data.impls).find(v => data.impls[v]?.address === implAddress);
+  const versionWithoutMetadata = Object.keys(data.impls).find(
+    v => data.impls[v]?.address === implAddress || data.impls[v]?.allAddresses?.includes(implAddress),
+  );
   if (versionWithoutMetadata === undefined) {
-    throw new Error(`Deployment at address ${implAddress} is not registered`);
+    throw new UpgradesError(
+      `Deployment at address ${implAddress} is not registered`,
+      () => 'To register a previously deployed proxy for upgrading, use the forceImport function.',
+    );
   }
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   const { layout } = data.impls[versionWithoutMetadata]!;
-
   if (isCurrentLayoutVersion(layout)) {
     return layout;
   } else {

package/src/manifest.test.ts

@@ -1,5 +1,5 @@
 import test from 'ava';
-import { Manifest } from './manifest';
+import { Manifest, ManifestData, normalizeManifestData } from './manifest';
 
 test('manifest name for a known network', t => {
   const manifest = new Manifest(1);
@@ -11,3 +11,36 @@ test('manifest name for an unknown network', t => {
   const manifest = new Manifest(id);
   t.is(manifest.file, `.openzeppelin/unknown-${id}.json`);
 });
+
+test('normalize manifest', t => {
+  const deployment = {
+    address: '0x1234',
+    txHash: '0x1234',
+    kind: 'uups' as const,
+    layout: { types: {}, storage: [] },
+    deployTransaction: {},
+  };
+  const input: ManifestData = {
+    manifestVersion: '3.0',
+    admin: deployment,
+    impls: { a: deployment },
+    proxies: [deployment],
+  };
+  const norm = normalizeManifestData(input);
+  t.like(norm.admin, {
+    ...deployment,
+    kind: undefined,
+    layout: undefined,
+    deployTransaction: undefined,
+  });
+  t.like(norm.impls.a, {
+    ...deployment,
+    kind: undefined,
+    deployTransaction: undefined,
+  });
+  t.like(norm.proxies[0], {
+    ...deployment,
+    layout: undefined,
+    deployTransaction: undefined,
+  });
+});

package/src/manifest.ts

@@ -22,6 +22,7 @@ export interface ManifestData {
 
 export interface ImplDeployment extends Deployment {
   layout: StorageLayout;
+  allAddresses?: string[];
 }
 
 export interface ProxyDeployment extends Deployment {
@@ -57,7 +58,10 @@ export class Manifest {
 
   async getDeploymentFromAddress(address: string): Promise<ImplDeployment> {
     const data = await this.read();
-    const deployment = Object.values(data.impls).find(d => d?.address === address);
+    const deployment = Object.values(data.impls).find(
+      d => d?.address === address || d?.allAddresses?.includes(address),
+    );
+
     if (deployment === undefined) {
       throw new DeploymentNotFound(`Deployment at address ${address} is not registered`);
     }
@@ -160,11 +164,12 @@ export function migrateManifest(data: ManifestData): ManifestData {
 
 export class DeploymentNotFound extends Error {}
 
-function normalizeManifestData(input: ManifestData): ManifestData {
+export function normalizeManifestData(input: ManifestData): ManifestData {
   return {
-    ...pick(input, ['manifestVersion', 'admin']),
+    manifestVersion: input.manifestVersion,
+    admin: input.admin && normalizeDeployment(input.admin),
     proxies: input.proxies.map(p => normalizeDeployment(p, ['kind'])),
-    impls: mapValues(input.impls, i => i && normalizeDeployment(i, ['layout'])),
+    impls: mapValues(input.impls, i => i && normalizeDeployment(i, ['layout', 'allAddresses'])),
   };
 }
 

package/src/provider.ts

@@ -71,7 +71,11 @@ export async function call(
 
 export async function hasCode(provider: EthereumProvider, address: string, block?: string): Promise<boolean> {
   const code = await getCode(provider, address, block);
-  return code !== '0x';
+  return !isEmpty(code);
+}
+
+export function isEmpty(code: string) {
+  return code.replace(/^0x/, '') === '';
 }
 
 export async function getTransactionByHash(

package/src/proxy-kind.ts

@@ -1,9 +1,10 @@
 import { EthereumProvider } from './provider';
 import { inferProxyKind, ValidationData, ValidationOptions } from './validate';
 import { Manifest, DeploymentNotFound, ProxyDeployment } from './manifest';
-import { isBeaconProxy } from './eip-1967-type';
+import { isBeaconProxy, isTransparentOrUUPSProxy, isTransparentProxy } from './eip-1967-type';
 import { Version } from './version';
 import { BeaconProxyUnsupportedError } from './usage-error';
+import { UpgradesError } from '.';
 
 export async function setProxyKind(
   provider: EthereumProvider,
@@ -57,3 +58,25 @@ export async function processProxyKind(
     throw new BeaconProxyUnsupportedError();
   }
 }
+
+/**
+ * Detects the kind of proxy at an address by reading its ERC 1967 storage slots.
+ *
+ * @param provider the Ethereum provider
+ * @param proxyAddress the proxy address
+ * @returns the proxy kind
+ * @throws {UpgradesError} if the contract at address does not look like an ERC 1967 proxy
+ */
+export async function detectProxyKind(provider: EthereumProvider, proxyAddress: string) {
+  let importKind: ProxyDeployment['kind'];
+  if (await isTransparentProxy(provider, proxyAddress)) {
+    importKind = 'transparent';
+  } else if (await isTransparentOrUUPSProxy(provider, proxyAddress)) {
+    importKind = 'uups';
+  } else if (await isBeaconProxy(provider, proxyAddress)) {
+    importKind = 'beacon';
+  } else {
+    throw new UpgradesError(`Contract at ${proxyAddress} doesn't look like an ERC 1967 proxy`);
+  }
+  return importKind;
+}

package/src/scripts/migrate-oz-cli-project.test.ts

@@ -50,7 +50,7 @@ test('produces network export data', async t => {
 
 test('deletes project file', async t => {
   const error = await t.throwsAsync(() => fs.access(PROJECT_FILE));
-  t.is(error.message, `ENOENT: no such file or directory, access '${PROJECT_FILE}'`);
+  t.is(error?.message, `ENOENT: no such file or directory, access '${PROJECT_FILE}'`);
 });
 
 test('export file contains networks and compiler data', async t => {

package/src/solc-api.ts

@@ -1,4 +1,5 @@
 import type { SourceUnit } from 'solidity-ast';
+import { StorageItem, TypeItem } from './storage';
 
 export interface SolcOutput {
   contracts: {
@@ -8,6 +9,10 @@ export interface SolcOutput {
           bytecode: SolcBytecode;
           methodIdentifiers?: Record<string, string>;
         };
+        storageLayout?: {
+          storage: StorageItem[];
+          types: Record<string, TypeItem>;
+        };
       };
     };
   };