@openzeppelin/upgrades-core 1.12.0 → 1.14.0

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>;
+        };
       };
     };
   };

package/src/standalone.test.ts

@@ -1,4 +1,4 @@
-import _test, { TestInterface } from 'ava';
+import _test, { TestFn } from 'ava';
 import { artifacts } from 'hardhat';
 
 import { SolcInput, SolcOutput } from './solc-api';
@@ -9,7 +9,7 @@ interface Context {
   solcOutput: SolcOutput;
 }
 
-const test = _test as TestInterface<Context>;
+const test = _test as TestFn<Context>;
 
 test.before(async t => {
   const buildInfo = await artifacts.getBuildInfo('contracts/test/Standalone.sol:StandaloneV1');

package/src/storage/compare.ts

@@ -1,7 +1,7 @@
 import { levenshtein, Operation } from '../levenshtein';
-import { ParsedTypeDetailed, StorageItem as _StorageItem } from './layout';
+import { hasLayout, ParsedTypeDetailed, isEnumMembers, isStructMembers } from './layout';
 import { UpgradesError } from '../error';
-import { StructMember as _StructMember, isEnumMembers, isStructMembers } from './layout';
+import { StorageItem as _StorageItem, StructMember as _StructMember, StorageField as _StorageField } from './layout';
 import { LayoutCompatibilityReport } from './report';
 import { assert } from '../utils/assert';
 import { isValueType } from '../utils/is-value-type';
@@ -9,7 +9,7 @@ import { isValueType } from '../utils/is-value-type';
 export type StorageItem = _StorageItem<ParsedTypeDetailed>;
 type StructMember = _StructMember<ParsedTypeDetailed>;
 
-export type StorageField = StorageItem | StructMember;
+export type StorageField = _StorageField<ParsedTypeDetailed>;
 export type StorageOperation<F extends StorageField> = Operation<F, StorageFieldChange<F>>;
 
 export type EnumOperation = Operation<string, { kind: 'replace'; original: string; updated: string }>;
@@ -17,6 +17,7 @@ export type EnumOperation = Operation<string, { kind: 'replace'; original: strin
 type StorageFieldChange<F extends StorageField> = (
   | { kind: 'replace' | 'rename' }
   | { kind: 'typechange'; change: TypeChange }
+  | { kind: 'layoutchange'; change: LayoutChange }
 ) & {
   original: F;
   updated: F;
@@ -28,6 +29,7 @@ export type TypeChange = (
         | 'obvious mismatch'
         | 'unknown'
         | 'array grow'
+        | 'visibility change'
         | 'array shrink'
         | 'array dynamic'
         | 'enum resize'
@@ -51,6 +53,13 @@ export type TypeChange = (
   updated: ParsedTypeDetailed;
 };
 
+export interface LayoutChange {
+  uncertain?: boolean;
+  slot?: Record<'from' | 'to', string>;
+  offset?: Record<'from' | 'to', number>;
+  bytes?: Record<'from' | 'to', string>;
+}
+
 export class StorageLayoutComparator {
   hasAllowedUncheckedCustomTypes = false;
 
@@ -78,16 +87,53 @@ export class StorageLayoutComparator {
     }
   }
 
-  getFieldChange<F extends StorageField>(original: F, updated: F): StorageFieldChange<F> | undefined {
-    const nameChange = !this.unsafeAllowRenames && original.label !== updated.label;
-    const typeChange = this.getTypeChange(original.type, updated.type, { allowAppend: false });
+  getVisibilityChange(original: ParsedTypeDetailed, updated: ParsedTypeDetailed): TypeChange | undefined {
+    const re = /^t_function_(internal|external)/;
+    const originalVisibility = original.head.match(re);
+    const updatedVisibility = updated.head.match(re);
+    assert(originalVisibility && updatedVisibility);
+    if (originalVisibility[0] !== updatedVisibility[0]) {
+      return { kind: 'visibility change', original, updated };
+    }
+  }
 
-    if (typeChange && nameChange) {
+  getFieldChange<F extends StorageField>(original: F, updated: F): StorageFieldChange<F> | undefined {
+    const nameChange = !this.unsafeAllowRenames && original.label !== (updated.renamedFrom ?? updated.label);
+    const retypedFromOriginal = original.type.item.label === updated.retypedFrom?.trim();
+    const typeChange = !retypedFromOriginal && this.getTypeChange(original.type, updated.type, { allowAppend: false });
+    const layoutChange = this.getLayoutChange(original, updated);
+
+    if (updated.retypedFrom && layoutChange) {
+      return { kind: 'layoutchange', original, updated, change: layoutChange };
+    } else if (typeChange && nameChange) {
       return { kind: 'replace', original, updated };
     } else if (nameChange) {
       return { kind: 'rename', original, updated };
     } else if (typeChange) {
       return { kind: 'typechange', change: typeChange, original, updated };
+    } else if (layoutChange && !layoutChange.uncertain) {
+      // Any layout change should be caught earlier as a type change, but we
+      // add this check as a safety fallback.
+      return { kind: 'layoutchange', original, updated, change: layoutChange };
+    }
+  }
+
+  getLayoutChange(original: StorageField, updated: StorageField): LayoutChange | undefined {
+    const validPair = ['uint8', 'bool'];
+    const knownCompatibleTypes =
+      validPair.includes(original.type.item.label) && validPair.includes(updated.type.item.label);
+    if (original.type.item.label == updated.type.item.label || knownCompatibleTypes) {
+      return undefined;
+    } else if (hasLayout(original) && hasLayout(updated)) {
+      const change = <T>(from: T, to: T) => (from === to ? undefined : { from, to });
+      const slot = change(original.slot, updated.slot);
+      const offset = change(original.offset, updated.offset);
+      const bytes = change(original.type.item.numberOfBytes, updated.type.item.numberOfBytes);
+      if (slot || offset || bytes) {
+        return { slot, offset, bytes };
+      }
+    } else {
+      return { uncertain: true };
     }
   }
 
@@ -97,7 +143,6 @@ export class StorageLayoutComparator {
     { allowAppend }: { allowAppend: boolean },
   ): TypeChange | undefined {
     const key = JSON.stringify({ original: original.id, updated: updated.id, allowAppend });
-
     if (this.cache.has(key)) {
       return this.cache.get(key);
     }
@@ -121,6 +166,10 @@ export class StorageLayoutComparator {
     updated: ParsedTypeDetailed,
     { allowAppend }: { allowAppend: boolean },
   ): TypeChange | undefined {
+    if (updated.head.startsWith('t_function')) {
+      return this.getVisibilityChange(original, updated);
+    }
+
     if (original.head !== updated.head) {
       return { kind: 'obvious mismatch', original, updated };
     }