@openzeppelin/upgrades-core 1.16.1 → 1.19.0

package/src/manifest.test.ts

@@ -1,5 +1,107 @@
-import test from 'ava';
+import test, { ExecutionContext } from 'ava';
 import { Manifest, ManifestData, normalizeManifestData } from './manifest';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+async function writeTestManifest(file: string) {
+  const testManifest = {
+    manifestVersion: '3.2',
+    impls: {},
+    proxies: [
+      {
+        address: '0x123',
+        txHash: '0x0',
+        kind: 'uups',
+      },
+    ],
+  };
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, JSON.stringify(testManifest, null, 2) + '\n');
+}
+
+async function deleteFile(t: ExecutionContext, file: string) {
+  try {
+    await fs.unlink(file);
+  } catch (e: any) {
+    if (!e.message.includes('ENOENT')) {
+      t.fail(e);
+    }
+  }
+}
+
+async function assertOldName(t: ExecutionContext<unknown>, id: number) {
+  await fs.access(`.openzeppelin/unknown-${id}.json`);
+  t.throwsAsync(fs.access(`.openzeppelin/polygon-mumbai.json`));
+}
+
+async function assertNewName(t: ExecutionContext<unknown>, id: number) {
+  t.throwsAsync(fs.access(`.openzeppelin/unknown-${id}.json`));
+  await fs.access(`.openzeppelin/polygon-mumbai.json`);
+}
+
+async function deleteManifests(t: ExecutionContext<unknown>, id: number) {
+  await deleteFile(t, `.openzeppelin/unknown-${id}.json`);
+  await deleteFile(t, '.openzeppelin/polygon-mumbai.json');
+}
+
+test.serial('multiple manifests', async t => {
+  const id = 80001;
+  await deleteManifests(t, id);
+
+  await writeTestManifest(`.openzeppelin/unknown-${id}.json`);
+  await writeTestManifest(`.openzeppelin/polygon-mumbai.json`);
+
+  const manifest = new Manifest(id);
+  await manifest.lockedRun(async () => {
+    await t.throwsAsync(() => manifest.read(), {
+      message: new RegExp(
+        `Network files with different names .openzeppelin/unknown-${id}.json and .openzeppelin/polygon-mumbai.json were found for the same network.`,
+      ),
+    });
+  });
+
+  await deleteManifests(t, id);
+});
+
+test.serial('rename manifest', async t => {
+  const id = 80001;
+  await deleteManifests(t, id);
+
+  await writeTestManifest(`.openzeppelin/unknown-${id}.json`);
+
+  const manifest = new Manifest(id);
+  t.is(manifest.file, `.openzeppelin/polygon-mumbai.json`);
+
+  t.throwsAsync(fs.access(`.openzeppelin/chain-${id}.lock`));
+
+  await assertOldName(t, id);
+  await manifest.lockedRun(async () => {
+    await fs.access(`.openzeppelin/chain-${id}.lock`);
+    const data = await manifest.read();
+    data.proxies.push({
+      address: '0x456',
+      txHash: '0x0',
+      kind: 'uups',
+    });
+
+    await assertOldName(t, id);
+    await manifest.write(data);
+    await assertNewName(t, id);
+  });
+  await assertNewName(t, id);
+
+  t.throwsAsync(fs.access(`.openzeppelin/chain-${id}.lock`));
+
+  // check that the contents were persisted
+  const data = await new Manifest(id).read();
+  t.true(data.proxies[0].address === '0x123');
+  t.true(data.proxies[1].address === '0x456');
+  await assertNewName(t, id);
+
+  t.throwsAsync(fs.access(`.openzeppelin/chain-${id}.lock`));
+
+  await deleteManifests(t, id);
+});
 
 test('manifest name for a known network', t => {
   const manifest = new Manifest(1);

package/src/manifest.ts

@@ -8,6 +8,7 @@ import type { Deployment } from './deployment';
 import type { StorageLayout } from './storage';
 import { pick } from './utils/pick';
 import { mapValues } from './utils/map-values';
+import { UpgradesError } from './error';
 
 const currentManifestVersion = '3.2';
 
@@ -40,15 +41,23 @@ function defaultManifest(): ManifestData {
 const manifestDir = '.openzeppelin';
 
 export class Manifest {
+  readonly chainId: number;
   readonly file: string;
+  private readonly fallbackFile: string;
+
   private locked = false;
 
   static async forNetwork(provider: EthereumProvider): Promise<Manifest> {
     return new Manifest(await getChainId(provider));
   }
 
-  constructor(readonly chainId: number) {
-    const name = networkNames[chainId] ?? `unknown-${chainId}`;
+  constructor(chainId: number) {
+    this.chainId = chainId;
+
+    const fallbackName = `unknown-${this.chainId}`;
+    this.fallbackFile = path.join(manifestDir, `${fallbackName}.json`);
+
+    const name = networkNames[this.chainId] ?? fallbackName;
     this.file = path.join(manifestDir, `${name}.json`);
   }
 
@@ -89,10 +98,55 @@ export class Manifest {
     });
   }
 
+  private async exists(file: string): Promise<boolean> {
+    try {
+      await fs.access(file);
+      return true;
+    } catch (e: any) {
+      return false;
+    }
+  }
+
+  private async readFile(): Promise<string> {
+    if (this.file === this.fallbackFile) {
+      return await fs.readFile(this.file, 'utf8');
+    } else {
+      const fallbackExists = await this.exists(this.fallbackFile);
+      const fileExists = await this.exists(this.file);
+
+      if (fileExists && fallbackExists) {
+        throw new UpgradesError(
+          `Network files with different names ${this.fallbackFile} and ${this.file} were found for the same network.`,
+          () =>
+            `More than one network file was found for chain ID ${this.chainId}. Determine which file is the most up to date version, then take a backup of and delete the other file.`,
+        );
+      } else if (fallbackExists) {
+        return await fs.readFile(this.fallbackFile, 'utf8');
+      } else {
+        return await fs.readFile(this.file, 'utf8');
+      }
+    }
+  }
+
+  private async writeFile(content: string): Promise<void> {
+    await this.renameFileIfRequired();
+    await fs.writeFile(this.file, content);
+  }
+
+  private async renameFileIfRequired() {
+    if (this.file !== this.fallbackFile && (await this.exists(this.fallbackFile))) {
+      try {
+        await fs.rename(this.fallbackFile, this.file);
+      } catch (e: any) {
+        throw new Error(`Failed to rename network file from ${this.fallbackFile} to ${this.file}: ${e.message}`);
+      }
+    }
+  }
+
   async read(): Promise<ManifestData> {
     const release = this.locked ? undefined : await this.lock();
     try {
-      const data = JSON.parse(await fs.readFile(this.file, 'utf8')) as ManifestData;
+      const data = JSON.parse(await this.readFile()) as ManifestData;
       return validateOrUpdateManifestVersion(data);
     } catch (e: any) {
       if (e.code === 'ENOENT') {
@@ -110,7 +164,7 @@ export class Manifest {
       throw new Error('Manifest must be locked');
     }
     const normalized = normalizeManifestData(data);
-    await fs.writeFile(this.file, JSON.stringify(normalized, null, 2) + '\n');
+    await this.writeFile(JSON.stringify(normalized, null, 2) + '\n');
   }
 
   async lockedRun<T>(cb: () => Promise<T>): Promise<T> {
@@ -126,8 +180,10 @@ export class Manifest {
   }
 
   private async lock() {
-    await fs.mkdir(path.dirname(this.file), { recursive: true });
-    const release = await lockfile.lock(this.file, { retries: 3, realpath: false });
+    const lockfileName = path.join(manifestDir, `chain-${this.chainId}`);
+
+    await fs.mkdir(path.dirname(lockfileName), { recursive: true });
+    const release = await lockfile.lock(lockfileName, { retries: 3, realpath: false });
     this.locked = true;
     return async () => {
       await release();

package/src/provider.ts

@@ -1,5 +1,3 @@
-import BN from 'bn.js';
-
 export interface EthereumProvider {
   send(method: 'web3_clientVersion', params: []): Promise<string>;
   send(method: 'net_version', params: []): Promise<string>;
@@ -33,7 +31,7 @@ export async function getNetworkId(provider: EthereumProvider): Promise<string>
 
 export async function getChainId(provider: EthereumProvider): Promise<number> {
   const id = await provider.send('eth_chainId', []);
-  return new BN(id.replace(/^0x/, ''), 'hex').toNumber();
+  return parseInt(id.replace(/^0x/, ''), 16);
 }
 
 export async function getClientVersion(provider: EthereumProvider): Promise<string> {
@@ -104,6 +102,10 @@ export const networkNames: { [chainId in number]?: string } = Object.freeze({
   4: 'rinkeby',
   5: 'goerli',
   42: 'kovan',
+  137: 'polygon',
+  80001: 'polygon-mumbai',
+  43113: 'avalanche-fuji',
+  43114: 'avalanche',
 });
 
 export async function isDevelopmentNetwork(provider: EthereumProvider): Promise<boolean> {

package/src/storage/compare.ts

@@ -1,10 +1,11 @@
-import { levenshtein, Operation } from '../levenshtein';
+import { Cost, levenshtein, Operation } from '../levenshtein';
 import { hasLayout, ParsedTypeDetailed, isEnumMembers, isStructMembers } from './layout';
 import { UpgradesError } from '../error';
 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';
+import { endMatchesGap, isGap } from './gap';
 
 export type StorageItem = _StorageItem<ParsedTypeDetailed>;
 type StructMember = _StructMember<ParsedTypeDetailed>;
@@ -15,13 +16,14 @@ export type StorageOperation<F extends StorageField> = Operation<F, StorageField
 export type EnumOperation = Operation<string, { kind: 'replace'; original: string; updated: string }>;
 
 type StorageFieldChange<F extends StorageField> = (
-  | { kind: 'replace' | 'rename' }
+  | { kind: 'replace' | 'rename' | 'finishgap' }
   | { kind: 'typechange'; change: TypeChange }
   | { kind: 'layoutchange'; change: LayoutChange }
+  | { kind: 'shrinkgap'; change: TypeChange }
 ) & {
   original: F;
   updated: F;
-};
+} & Cost;
 
 export type TypeChange = (
   | {
@@ -55,11 +57,45 @@ export type TypeChange = (
 
 export interface LayoutChange {
   uncertain?: boolean;
+  knownCompatible?: boolean;
   slot?: Record<'from' | 'to', string>;
   offset?: Record<'from' | 'to', number>;
   bytes?: Record<'from' | 'to', string>;
 }
 
+/**
+ * Gets the storage field's begin position as the number of bytes from 0.
+ *
+ * @param field the storage field
+ * @returns the begin position, or undefined if the slot or offset is undefined
+ */
+export function storageFieldBegin(field: StorageField): bigint | undefined {
+  if (field.slot === undefined || field.offset === undefined) {
+    return undefined;
+  }
+  return BigInt(field.slot) * 32n + BigInt(field.offset);
+}
+
+/**
+ * Gets the storage field's end position as the number of bytes from 0.
+ *
+ * @param field the storage field
+ * @returns the end position, or undefined if the slot or offset or number of bytes is undefined
+ */
+export function storageFieldEnd(field: StorageField): bigint | undefined {
+  const begin = storageFieldBegin(field);
+  const numberOfBytes = field.type.item.numberOfBytes;
+  if (begin === undefined || numberOfBytes === undefined) {
+    return undefined;
+  }
+  return begin + BigInt(numberOfBytes);
+}
+
+const LAYOUTCHANGE_COST = 0;
+const FINISHGAP_COST = 1;
+const SHRINKGAP_COST = 0;
+const TYPECHANGE_COST = 0;
+
 export class StorageLayoutComparator {
   hasAllowedUncheckedCustomTypes = false;
 
@@ -80,10 +116,39 @@ export class StorageLayoutComparator {
   ): StorageOperation<F>[] {
     const ops = levenshtein(original, updated, (a, b) => this.getFieldChange(a, b));
 
-    if (allowAppend) {
-      return ops.filter(o => o.kind !== 'append');
-    } else {
-      return ops;
+    // filter operations: the callback function returns true if operation is unsafe, false if safe
+    return ops.filter(o => {
+      if (o.kind === 'insert') {
+        const updatedStart = storageFieldBegin(o.updated);
+        const updatedEnd = storageFieldEnd(o.updated);
+        // If we cannot get the updated position, or if any entry in the original layout (that is not a gap) overlaps, then the insertion is unsafe.
+        return (
+          updatedStart === undefined ||
+          updatedEnd === undefined ||
+          original
+            .filter(entry => !isGap(entry))
+            .some(entry => {
+              const origStart = storageFieldBegin(entry);
+              const origEnd = storageFieldEnd(entry);
+              return (
+                origStart === undefined ||
+                origEnd === undefined ||
+                overlaps(origStart, origEnd, updatedStart, updatedEnd)
+              );
+            })
+        );
+      } else if ((o.kind === 'shrinkgap' || o.kind === 'finishgap') && endMatchesGap(o.original, o.updated)) {
+        // Gap shrink or gap replacement that finishes on the same slot is safe
+        return false;
+      } else if (o.kind === 'append' && allowAppend) {
+        return false;
+      }
+      return true;
+    });
+
+    // https://stackoverflow.com/questions/325933/determine-whether-two-date-ranges-overlap
+    function overlaps(startA: bigint, endA: bigint, startB: bigint, endB: bigint) {
+      return startA < endB && startB < endA;
     }
   }
 
@@ -107,28 +172,29 @@ export class StorageLayoutComparator {
     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 };
+    if (updated.retypedFrom && layoutChange && (!layoutChange.uncertain || !layoutChange.knownCompatible)) {
+      return { kind: 'layoutchange', original, updated, change: layoutChange, cost: LAYOUTCHANGE_COST };
+    } else if (nameChange && endMatchesGap(original, updated)) {
+      // original is a gap that was consumed by a non-gap ending at the same slot, which is safe
+      return { kind: 'finishgap', original, updated, cost: FINISHGAP_COST };
+    } else if (typeChange && typeChange.kind === 'array shrink' && endMatchesGap(original, updated)) {
+      // original and updated are a gap that was shrunk and ends at the same slot, which is safe
+      return { kind: 'shrinkgap', change: typeChange, original, updated, cost: SHRINKGAP_COST };
     } 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 };
+      return { kind: 'typechange', change: typeChange, original, updated, cost: TYPECHANGE_COST };
     } 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 };
+      return { kind: 'layoutchange', original, updated, change: layoutChange, cost: LAYOUTCHANGE_COST };
     }
   }
 
   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)) {
+    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);
@@ -137,7 +203,11 @@ export class StorageLayoutComparator {
         return { slot, offset, bytes };
       }
     } else {
-      return { uncertain: true };
+      const validChanges = [['uint8', 'bool']];
+      const knownCompatible = validChanges.some(
+        group => group.includes(original.type.item.label) && group.includes(updated.type.item.label),
+      );
+      return { uncertain: true, knownCompatible };
     }
   }
 

package/src/storage/gap.ts

@@ -0,0 +1,26 @@
+import { StorageField, storageFieldEnd } from './compare';
+
+/**
+ * Returns true if the field represents a storage gap.
+ *
+ * @param field the storage field
+ * @returns true if field is a gap, otherwise false
+ */
+export function isGap(field: StorageField): boolean {
+  return field.label === '__gap' && field.type.head === 't_array';
+}
+
+/**
+ * Returns true if original storage field is a gap and the updated storage field
+ * ends at the exact same position as the gap.
+ *
+ * @param original the original storage field
+ * @param updated the updated storage field
+ * @returns true if original is a gap and original and updated end at the same position, otherwise false
+ */
+export function endMatchesGap(original: StorageField, updated: StorageField) {
+  const originalEnd = storageFieldEnd(original);
+  const updatedEnd = storageFieldEnd(updated);
+
+  return isGap(original) && originalEnd !== undefined && updatedEnd !== undefined && originalEnd === updatedEnd;
+}

package/src/storage/report-gap.test.ts

@@ -0,0 +1,119 @@
+import _test, { TestFn } from 'ava';
+import { ContractDefinition } from 'solidity-ast';
+import { ASTDereferencer, findAll } from 'solidity-ast/utils';
+import { artifacts } from 'hardhat';
+import { astDereferencer } from '../ast-dereferencer';
+import { extractStorageLayout } from './extract';
+import { StorageLayoutComparator } from './compare';
+import { StorageLayout, getDetailedLayout } from './layout';
+
+interface Context {
+  extractStorageLayout: (contract: string) => ReturnType<typeof extractStorageLayout>;
+}
+
+const test = _test as TestFn<Context>;
+
+const dummyDecodeSrc = () => 'file.sol:1';
+const testContracts = [
+  'contracts/test/Storage.sol:StorageUpgrade_Gap_V1',
+  'contracts/test/Storage.sol:StorageUpgrade_Gap_V2_Ok',
+  'contracts/test/Storage.sol:StorageUpgrade_Gap_V2_Bad1',
+  'contracts/test/Storage.sol:StorageUpgrade_Gap_V2_Bad2',
+  'contracts/test/Storage.sol:StorageUpgrade_Gap_V2_Bad3',
+  'contracts/test/Storage.sol:StorageUpgrade_Gap_V2_Bad4',
+  'contracts/test/Storage.sol:StorageUpgrade_Gap_V2_Bad5',
+  'contracts/test/Storage.sol:StorageUpgrade_MultiConsumeGap_V1',
+  'contracts/test/Storage.sol:StorageUpgrade_MultiConsumeGap_V2_Ok',
+];
+
+test.before(async t => {
+  const contracts: Record<string, ContractDefinition> = {};
+  const deref: Record<string, ASTDereferencer> = {};
+  const storageLayout: Record<string, StorageLayout> = {};
+  for (const contract of testContracts) {
+    const buildInfo = await artifacts.getBuildInfo(contract);
+    if (buildInfo === undefined) {
+      throw new Error(`Build info not found for contract ${contract}`);
+    }
+    const solcOutput = buildInfo.output;
+    for (const def of findAll('ContractDefinition', solcOutput.sources['contracts/test/Storage.sol'].ast)) {
+      contracts[def.name] = def;
+      deref[def.name] = astDereferencer(solcOutput);
+      storageLayout[def.name] = (solcOutput.contracts['contracts/test/Storage.sol'][def.name] as any).storageLayout;
+    }
+  }
+
+  t.context.extractStorageLayout = name =>
+    extractStorageLayout(contracts[name], dummyDecodeSrc, deref[name], storageLayout[name]);
+});
+
+function getReport(original: StorageLayout, updated: StorageLayout) {
+  const originalDetailed = getDetailedLayout(original);
+  const updatedDetailed = getDetailedLayout(updated);
+  const comparator = new StorageLayoutComparator();
+  return comparator.compareLayouts(originalDetailed, updatedDetailed);
+}
+
+test('shrinkgap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Gap_V1');
+  const v2 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Ok');
+  const report = getReport(v1, v2);
+  t.true(report.ok);
+  t.is(report.explain(), '');
+});
+
+test('finishgap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_MultiConsumeGap_V1');
+  const v2 = t.context.extractStorageLayout('StorageUpgrade_MultiConsumeGap_V2_Ok');
+  const report = getReport(v1, v2);
+  t.true(report.ok);
+  t.is(report.explain(), '');
+});
+
+test('insert var without shrink gap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Gap_V1');
+  const v2 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Bad1');
+  const report = getReport(v1, v2);
+  t.false(report.ok);
+  t.snapshot(report.explain());
+});
+
+test('delete var and expand gap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Gap_V1');
+  const v2 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Bad2');
+  const report = getReport(v1, v2);
+  t.false(report.ok);
+  t.snapshot(report.explain());
+});
+
+test('shrink gap without adding var', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Gap_V1');
+  const v2 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Bad3');
+  const report = getReport(v1, v2);
+  t.false(report.ok);
+  t.snapshot(report.explain());
+});
+
+test('insert var and shrink gap too much', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Gap_V1');
+  const v2 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Bad4');
+  const report = getReport(v1, v2);
+  t.false(report.ok);
+  t.snapshot(report.explain());
+});
+
+test('insert vars and shrink gap not enough', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Gap_V1');
+  const v2 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Bad5');
+  const report = getReport(v1, v2);
+  t.false(report.ok);
+  t.snapshot(report.explain());
+});
+
+test('insert vars without shrink gap (uint128)', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Uint128Gap_V1');
+  const v2 = t.context.extractStorageLayout('StorageUpgrade_Uint128Gap_V2_Bad');
+  const report = getReport(v1, v2);
+  t.false(report.ok);
+  t.snapshot(report.explain());
+});

package/src/storage/report-gap.test.ts.md

@@ -0,0 +1,59 @@
+# Snapshot report for `src/storage/report-gap.test.ts`
+
+The actual snapshot is saved in `report-gap.test.ts.snap`.
+
+Generated by [AVA](https://avajs.dev).
+
+## insert var without shrink gap
+
+> Snapshot 1
+
+    `file.sol:1: Layout changed for \`__gap\` (uint256[48] -> uint256[48])␊
+      - Slot changed from 2 to 3␊
+      > Set __gap array to size 47`
+
+## delete var and expand gap
+
+> Snapshot 1
+
+    `StorageUpgrade_Gap_V1: Deleted \`b\`␊
+      > Keep the variable even if unused␊
+    ␊
+    file.sol:1: Upgraded \`__gap\` to an incompatible type␊
+      - Bad storage gap resize from 48 to 49␊
+        Size cannot increase`
+
+## shrink gap without adding var
+
+> Snapshot 1
+
+    `file.sol:1: Upgraded \`__gap\` to an incompatible type␊
+      - Bad storage gap resize from 48 to 47␊
+        Size decrease must match with corresponding variable inserts␊
+      > Set __gap array to size 48`
+
+## insert var and shrink gap too much
+
+> Snapshot 1
+
+    `file.sol:1: Upgraded \`__gap\` to an incompatible type␊
+      - Bad storage gap resize from 48 to 46␊
+        Size decrease must match with corresponding variable inserts␊
+      > Set __gap array to size 47`
+
+## insert vars and shrink gap not enough
+
+> Snapshot 1
+
+    `file.sol:1: Upgraded \`__gap\` to an incompatible type␊
+      - Bad storage gap resize from 48 to 47␊
+        Size decrease must match with corresponding variable inserts␊
+      > Set __gap array to size 46`
+
+## insert vars without shrink gap (uint128)
+
+> Snapshot 1
+
+    `file.sol:1: Layout changed for \`__gap\` (uint128[49] -> uint128[49])␊
+      - Slot changed from 1 to 2␊
+      > Set __gap array to size 48`

package/src/storage/report-rename-retype.test.ts

@@ -6,6 +6,7 @@ import { astDereferencer } from '../ast-dereferencer';
 import { extractStorageLayout } from './extract';
 import { StorageLayoutComparator } from './compare';
 import { StorageLayout, getDetailedLayout } from './layout';
+import { getStorageUpgradeErrors } from '.';
 
 interface Context {
   extractStorageLayout: (contract: string) => ReturnType<typeof extractStorageLayout>;
@@ -25,6 +26,8 @@ const testContracts = [
   'contracts/test/RenamedRetyped.sol:ConfusingRetypeV2',
   'contracts/test/RenamedRetyped.sol:NonHardcodedRetypeV1',
   'contracts/test/RenamedRetyped.sol:NonHardcodedRetypeV2',
+  'contracts/test/RenamedRetyped.sol:LayoutChangeV1',
+  'contracts/test/RenamedRetyped.sol:LayoutChangeV2',
 ];
 
 test.before(async t => {
@@ -104,3 +107,27 @@ test('non-hardcoded retype', t => {
   t.true(report.ok);
   t.snapshot(report.explain());
 });
+
+test('retype with layout change', t => {
+  const v1 = t.context.extractStorageLayout('LayoutChangeV1');
+  const v2 = t.context.extractStorageLayout('LayoutChangeV2');
+
+  // ensure both variables' layout changes appear in the internal errors
+  t.like(getStorageUpgradeErrors(v1, v2), {
+    length: 2,
+    0: {
+      kind: 'layoutchange',
+      original: { label: 'a' },
+      updated: { label: 'a' },
+    },
+    1: {
+      kind: 'layoutchange',
+      original: { label: 'b' },
+      updated: { label: 'b' },
+    },
+  });
+
+  const report = getReport(v1, v2);
+  t.false(report.ok);
+  t.snapshot(report.explain());
+});

package/src/storage/report-rename-retype.test.ts.md

@@ -42,3 +42,10 @@ Generated by [AVA](https://avajs.dev).
 > Snapshot 1
 
     ''
+
+## retype with layout change
+
+> Snapshot 1
+
+    `file.sol:1: Layout changed for \`a\` (bool -> uint16)␊
+      - Number of bytes changed from 1 to 2`