@openzeppelin/upgrades-core 1.22.0 → 1.24.0

package/src/manifest.test.ts

@@ -1,15 +1,16 @@
+import os from 'os';
 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) {
+async function writeTestManifest(file: string, address?: string) {
   const testManifest = {
     manifestVersion: '3.2',
     impls: {},
     proxies: [
       {
-        address: '0x123',
+        address: address ?? '0x123',
         txHash: '0x0',
         kind: 'uups',
       },
@@ -94,8 +95,8 @@ test.serial('rename manifest', async t => {
 
   // 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');
+  t.is(data.proxies[0].address, '0x123');
+  t.is(data.proxies[1].address, '0x456');
   await assertNewName(t, id);
 
   t.throwsAsync(fs.access(`.openzeppelin/chain-${id}.lock`));
@@ -103,17 +104,332 @@ test.serial('rename manifest', async t => {
   await deleteManifests(t, id);
 });
 
+test.serial('rename hardhat from unknown to dev manifest', async t => {
+  const id = 31337;
+
+  await deleteFile(t, `.openzeppelin/unknown-${id}.json`);
+  await writeTestManifest(`.openzeppelin/unknown-${id}.json`);
+
+  const instanceId = '0xaa0';
+  const devInstanceMetadata = { networkName: 'hardhat', instanceId: instanceId };
+
+  const manifest = new Manifest(id, devInstanceMetadata, os.tmpdir());
+
+  await fs.access(`.openzeppelin/unknown-${id}.json`);
+  await manifest.lockedRun(async () => {
+    await fs.access(`${os.tmpdir()}/openzeppelin-upgrades/chain-${id}-${instanceId}.lock`);
+    const data = await manifest.read();
+    data.proxies.push({
+      address: '0x456',
+      txHash: '0x0',
+      kind: 'uups',
+    });
+
+    await fs.access(`.openzeppelin/unknown-${id}.json`);
+    await manifest.write(data);
+  });
+  t.throwsAsync(fs.access(`.openzeppelin/unknown-${id}.json`));
+  await fs.access(`${os.tmpdir()}/openzeppelin-upgrades/hardhat-${id}-${instanceId}.json`);
+
+  const dev = await new Manifest(id, devInstanceMetadata, os.tmpdir()).read();
+  t.is(dev.proxies.length, 2);
+  t.is(dev.proxies[0].address, '0x123');
+  t.is(dev.proxies[1].address, '0x456');
+
+  await deleteFile(t, `.openzeppelin/unknown-${id}.json`);
+  await deleteFile(t, `${os.tmpdir()}/openzeppelin-upgrades/hardhat-${id}-${instanceId}.json`);
+});
+
+test.serial('forked chain from known network with fallback name', async t => {
+  const forkedId = 80001;
+  const devId = 55555;
+
+  await deleteManifests(t, forkedId);
+
+  await writeTestManifest(`.openzeppelin/unknown-${forkedId}.json`);
+
+  const instanceId = '0xaaa';
+  const devInstanceMetadata = { networkName: 'hardhat', instanceId: instanceId, forkedNetwork: { chainId: forkedId } };
+
+  const manifest = new Manifest(devId, devInstanceMetadata, os.tmpdir());
+
+  await assertOldName(t, forkedId);
+  await manifest.lockedRun(async () => {
+    await fs.access(`${os.tmpdir()}/openzeppelin-upgrades/chain-${devId}-${instanceId}.lock`);
+    const data = await manifest.read();
+    data.proxies.push({
+      address: '0x456',
+      txHash: '0x0',
+      kind: 'uups',
+    });
+
+    await assertOldName(t, forkedId);
+    await manifest.write(data);
+    await assertOldName(t, forkedId); // original network file should not be changed
+  });
+  t.throwsAsync(fs.access(`.openzeppelin/chain-${forkedId}.lock`));
+  t.throwsAsync(fs.access(`${os.tmpdir()}/openzeppelin-upgrades/chain-${devId}-${instanceId}.lock`));
+  await fs.access(`${os.tmpdir()}/openzeppelin-upgrades/hardhat-${devId}-${instanceId}.json`);
+
+  // check that the contents were NOT persisted to original manifest
+  const orig = await new Manifest(forkedId).read();
+  t.is(orig.proxies.length, 1);
+  t.is(orig.proxies[0].address, '0x123');
+
+  // check that the contents were persisted to dev copy of manifest
+  const dev = await new Manifest(devId, devInstanceMetadata, os.tmpdir()).read();
+  t.is(dev.proxies.length, 2);
+  t.is(dev.proxies[0].address, '0x123');
+  t.is(dev.proxies[1].address, '0x456');
+
+  await deleteManifests(t, forkedId);
+  await deleteFile(t, `${os.tmpdir()}/openzeppelin-upgrades/hardhat-${devId}-${instanceId}.json`);
+});
+
+test.serial('forked chain from known network with actual name', async t => {
+  const forkedId = 80001;
+  const devId = 55555;
+
+  await deleteManifests(t, forkedId);
+
+  await writeTestManifest(`.openzeppelin/polygon-mumbai.json`);
+
+  const instanceId = '0xbbb';
+  const devInstanceMetadata = { networkName: 'hardhat', instanceId: instanceId, forkedNetwork: { chainId: forkedId } };
+
+  const manifest = new Manifest(devId, devInstanceMetadata, os.tmpdir());
+
+  await assertNewName(t, forkedId);
+  await manifest.lockedRun(async () => {
+    await fs.access(`${os.tmpdir()}/openzeppelin-upgrades/chain-${devId}-${instanceId}.lock`);
+    const data = await manifest.read();
+    data.proxies.push({
+      address: '0x456',
+      txHash: '0x0',
+      kind: 'uups',
+    });
+
+    await assertNewName(t, forkedId);
+    await manifest.write(data);
+    await assertNewName(t, forkedId); // original network file should not be changed
+  });
+  t.throwsAsync(fs.access(`.openzeppelin/chain-${forkedId}.lock`));
+  t.throwsAsync(fs.access(`${os.tmpdir()}/openzeppelin-upgrades/chain-${devId}-${instanceId}.lock`));
+  await fs.access(`${os.tmpdir()}/openzeppelin-upgrades/hardhat-${devId}-${instanceId}.json`);
+
+  // check that the contents were NOT persisted to original manifest
+  const orig = await new Manifest(forkedId).read();
+  t.is(orig.proxies.length, 1);
+  t.is(orig.proxies[0].address, '0x123');
+
+  // check that the contents were persisted to dev copy of manifest
+  const dev = await new Manifest(devId, devInstanceMetadata, os.tmpdir()).read();
+  t.is(dev.proxies.length, 2);
+  t.is(dev.proxies[0].address, '0x123');
+  t.is(dev.proxies[1].address, '0x456');
+
+  await deleteManifests(t, forkedId);
+  await deleteFile(t, `${os.tmpdir()}/openzeppelin-upgrades/hardhat-${devId}-${instanceId}.json`);
+});
+
+test.serial('forked chain, real manifest already locked', async t => {
+  const forkedId = 80001;
+  const devId = 55555;
+
+  const instanceId = '0xccc';
+  const devInstanceMetadata = { networkName: 'hardhat', instanceId: instanceId, forkedNetwork: { chainId: forkedId } };
+
+  const realManifest = new Manifest(forkedId);
+  const devManifest = new Manifest(devId, devInstanceMetadata, os.tmpdir());
+
+  try {
+    await realManifest.lockedRun(async () => {
+      await devManifest.read(0);
+    });
+    t.fail();
+  } catch (e: any) {
+    t.is(e.code, 'ELOCKED');
+  }
+});
+
+test.serial('forked chain, real manifest already locked but dev manifest exists', async t => {
+  const forkedId = 80001;
+  const devId = 55555;
+
+  const instanceId = '0xddd';
+  const devInstanceMetadata = { networkName: 'hardhat', instanceId: instanceId, forkedNetwork: { chainId: forkedId } };
+
+  const realManifest = new Manifest(forkedId);
+  const devManifest = new Manifest(devId, devInstanceMetadata, os.tmpdir());
+
+  // write dev manifest
+  await writeTestManifest(devManifest.file, '0x999');
+
+  // then write real manifest
+  await deleteManifests(t, forkedId);
+  await writeTestManifest(`.openzeppelin/polygon-mumbai.json`);
+
+  let devManifestContents;
+  await realManifest.lockedRun(async () => {
+    // should ignore real manifest and real lock file
+    devManifestContents = await devManifest.read();
+    t.is(devManifestContents.proxies.length, 1);
+    t.is(devManifestContents.proxies[0].address, '0x999');
+  });
+
+  await deleteManifests(t, forkedId);
+  await deleteFile(t, `${os.tmpdir()}/openzeppelin-upgrades/hardhat-${devId}-${instanceId}.json`);
+});
+
+test.serial('forked chain without existing manifest', async t => {
+  const forkedId = 80001;
+  const devId = 55555;
+
+  await deleteManifests(t, forkedId);
+
+  const instanceId = '0xeee';
+  const devInstanceMetadata = { networkName: 'hardhat', instanceId: instanceId, forkedNetwork: { chainId: forkedId } };
+
+  const manifest = new Manifest(devId, devInstanceMetadata, os.tmpdir());
+
+  await manifest.lockedRun(async () => {
+    await fs.access(`${os.tmpdir()}/openzeppelin-upgrades/chain-${devId}-${instanceId}.lock`);
+    const data = await manifest.read();
+    data.proxies.push({
+      address: '0x456',
+      txHash: '0x0',
+      kind: 'uups',
+    });
+
+    await manifest.write(data);
+  });
+  t.throwsAsync(fs.access(`${os.tmpdir()}/openzeppelin-upgrades/chain-${devId}-${instanceId}.lock`));
+  await fs.access(`${os.tmpdir()}/openzeppelin-upgrades/hardhat-${devId}-${instanceId}.json`);
+
+  // check that the contents were NOT persisted to regular manifest
+  t.throwsAsync(fs.access(`.openzeppelin/unknown-${forkedId}.json`));
+  t.throwsAsync(fs.access(`.openzeppelin/polygon-mumbai.json`));
+
+  // check that the contents were persisted to dev copy of manifest
+  const dev = await new Manifest(devId, devInstanceMetadata, os.tmpdir()).read();
+  t.is(dev.proxies.length, 1);
+  t.is(dev.proxies[0].address, '0x456');
+
+  await deleteManifests(t, forkedId);
+  await deleteFile(t, `${os.tmpdir()}/openzeppelin-upgrades/hardhat-${devId}-${instanceId}.json`);
+});
+
+test.serial('dev instance with known network id', async t => {
+  const devId = 80001;
+
+  await deleteManifests(t, devId);
+
+  // dev instance without forking, so this real manifest should not be actually used
+  await writeTestManifest(`.openzeppelin/polygon-mumbai.json`);
+
+  const instanceId = '0xfff';
+  const devInstanceMetadata = { networkName: 'hardhat', instanceId: instanceId };
+
+  const manifest = new Manifest(devId, devInstanceMetadata, os.tmpdir());
+
+  await manifest.lockedRun(async () => {
+    await fs.access(`${os.tmpdir()}/openzeppelin-upgrades/chain-${devId}-${instanceId}.lock`);
+    const data = await manifest.read();
+    data.proxies.push({
+      address: '0x456',
+      txHash: '0x0',
+      kind: 'uups',
+    });
+
+    await manifest.write(data);
+  });
+  t.throwsAsync(fs.access(`${os.tmpdir()}/openzeppelin-upgrades/chain-${devId}-${instanceId}.lock`));
+  await fs.access(`${os.tmpdir()}/openzeppelin-upgrades/hardhat-${devId}-${instanceId}.json`);
+
+  // check that the contents were NOT persisted to original manifest
+  const orig = await new Manifest(devId).read();
+  t.is(orig.proxies.length, 1);
+  t.is(orig.proxies[0].address, '0x123');
+
+  // check that the contents were persisted to dev manifest without original contents
+  const dev = await new Manifest(devId, devInstanceMetadata, os.tmpdir()).read();
+  t.is(dev.proxies.length, 1);
+  t.is(dev.proxies[0].address, '0x456');
+
+  await deleteManifests(t, devId);
+  await deleteFile(t, `${os.tmpdir()}/openzeppelin-upgrades/hardhat-${devId}-${instanceId}.json`);
+});
+
 test('manifest name for a known network', t => {
   const manifest = new Manifest(1);
   t.is(manifest.file, '.openzeppelin/mainnet.json');
 });
 
+test('manifest name for a known network, development instance', t => {
+  const chainId = 1;
+  const instanceId = '0x11111';
+  const devInstanceMetadata = { networkName: 'hardhat', instanceId: instanceId };
+
+  const manifest = new Manifest(chainId, devInstanceMetadata, '/tmp');
+
+  const expectedPath = `/tmp/openzeppelin-upgrades/hardhat-${chainId}-${instanceId}.json`;
+  t.is(manifest.file, expectedPath);
+  t.is(manifest.fallbackFile, expectedPath);
+});
+
 test('manifest name for an unknown network', t => {
   const id = 55555;
   const manifest = new Manifest(id);
   t.is(manifest.file, `.openzeppelin/unknown-${id}.json`);
 });
 
+test('manifest name for an unknown network, development instance, non hardhat', t => {
+  const chainId = 55555;
+  const instanceId = '0x22222';
+  const devInstanceMetadata = { networkName: 'dev', instanceId: instanceId };
+
+  const manifest = new Manifest(chainId, devInstanceMetadata, '/tmp');
+
+  const expectedPath = `/tmp/openzeppelin-upgrades/dev-${chainId}-${instanceId}.json`;
+  t.is(manifest.file, expectedPath);
+  t.is(manifest.fallbackFile, expectedPath);
+});
+
+test('manifest name for an unknown network, development instance, hardhat', t => {
+  const chainId = 31337;
+  const instanceId = '0x22223';
+  const devInstanceMetadata = { networkName: 'dev', instanceId: instanceId };
+
+  const manifest = new Manifest(chainId, devInstanceMetadata, '/tmp');
+
+  const expectedPath = `/tmp/openzeppelin-upgrades/dev-${chainId}-${instanceId}.json`;
+  t.is(manifest.file, expectedPath);
+  t.is(manifest.fallbackFile, `.openzeppelin/unknown-${chainId}.json`);
+});
+
+test('manifest dev instance without tmp dir param', t => {
+  const chainId = 1;
+  const instanceId = '0x33333';
+  const devInstanceMetadata = { networkName: 'hardhat', instanceId: instanceId };
+
+  t.throws(() => new Manifest(chainId, devInstanceMetadata));
+});
+
+test('manifest lock file name for a development network instance', async t => {
+  const chainId = 55555;
+  const instanceId = '0x55555';
+  const devInstanceMetadata = { networkName: 'hardhat', instanceId: instanceId };
+
+  const manifest = new Manifest(chainId, devInstanceMetadata, '/tmp');
+
+  await manifest.lockedRun(async () => {
+    t.throwsAsync(fs.access(`.openzeppelin/chain-${chainId}.lock`));
+    t.throwsAsync(fs.access(`.openzeppelin/chain-${chainId}-${instanceId}.lock`));
+    t.throwsAsync(fs.access(`/tmp/openzeppelin-upgrades/chain-${chainId}.lock`));
+    await fs.access(`/tmp/openzeppelin-upgrades/chain-${chainId}-${instanceId}.lock`);
+  });
+});
+
 test('normalize manifest', t => {
   const deployment = {
     address: '0x1234',

package/src/manifest.ts

@@ -1,6 +1,7 @@
+import os from 'os';
 import path from 'path';
 import { promises as fs } from 'fs';
-import { EthereumProvider, getChainId, networkNames } from './provider';
+import { EthereumProvider, getChainId, getHardhatMetadata, networkNames } from './provider';
 import lockfile from 'proper-lockfile';
 import { compare as compareVersions } from 'compare-versions';
 
@@ -9,6 +10,8 @@ import type { StorageLayout } from './storage';
 import { pick } from './utils/pick';
 import { mapValues } from './utils/map-values';
 import { UpgradesError } from './error';
+import debug from './utils/debug';
+import { assert } from './utils/assert';
 
 const currentManifestVersion = '3.2';
 
@@ -38,27 +41,109 @@ function defaultManifest(): ManifestData {
   };
 }
 
-const manifestDir = '.openzeppelin';
+const MANIFEST_DEFAULT_DIR = '.openzeppelin';
+const MANIFEST_TEMP_DIR = 'openzeppelin-upgrades';
+
+async function getDevInstanceMetadata(
+  provider: EthereumProvider,
+  chainId: number,
+): Promise<DevInstanceMetadata | undefined> {
+  let hardhatMetadata;
+
+  try {
+    hardhatMetadata = await getHardhatMetadata(provider);
+  } catch (e: unknown) {
+    return undefined;
+  }
+
+  if (hardhatMetadata.chainId !== chainId) {
+    throw new Error(
+      `Broken invariant: Hardhat metadata's chainId ${hardhatMetadata.chainId} does not match eth_chainId ${chainId}`,
+    );
+  }
+
+  return {
+    networkName: 'hardhat',
+    instanceId: hardhatMetadata.instanceId,
+    forkedNetwork: hardhatMetadata.forkedNetwork,
+  };
+}
+
+function getSuffix(chainId: number, devInstanceMetadata?: DevInstanceMetadata) {
+  if (devInstanceMetadata !== undefined) {
+    return `${chainId}-${devInstanceMetadata.instanceId}`;
+  } else {
+    return `${chainId}`;
+  }
+}
+
+interface DevInstanceMetadata {
+  networkName: string;
+  instanceId: string;
+  forkedNetwork?: {
+    // The chainId of the network that is being forked
+    chainId: number;
+  };
+}
 
 export class Manifest {
   readonly chainId: number;
   readonly file: string;
-  private readonly fallbackFile: string;
+  readonly fallbackFile: string;
+  private readonly dir: string;
+
+  private readonly chainIdSuffix: string;
+  private readonly parent?: Manifest;
 
   private locked = false;
 
   static async forNetwork(provider: EthereumProvider): Promise<Manifest> {
-    return new Manifest(await getChainId(provider));
+    const chainId = await getChainId(provider);
+    const devInstanceMetadata = await getDevInstanceMetadata(provider, chainId);
+    if (devInstanceMetadata !== undefined) {
+      return new Manifest(chainId, devInstanceMetadata, os.tmpdir());
+    } else {
+      return new Manifest(chainId);
+    }
   }
 
-  constructor(chainId: number) {
+  constructor(chainId: number, devInstanceMetadata?: DevInstanceMetadata, osTmpDir?: string) {
     this.chainId = chainId;
+    this.chainIdSuffix = getSuffix(chainId, devInstanceMetadata);
 
-    const fallbackName = `unknown-${this.chainId}`;
-    this.fallbackFile = path.join(manifestDir, `${fallbackName}.json`);
+    const defaultFallbackName = `unknown-${chainId}`;
 
-    const name = networkNames[this.chainId] ?? fallbackName;
-    this.file = path.join(manifestDir, `${name}.json`);
+    if (devInstanceMetadata !== undefined) {
+      assert(osTmpDir !== undefined);
+      this.dir = path.join(osTmpDir, MANIFEST_TEMP_DIR);
+      debug('development manifest directory:', this.dir);
+
+      const devName = `${devInstanceMetadata.networkName}-${this.chainIdSuffix}`;
+      const devFile = path.join(this.dir, `${devName}.json`);
+
+      this.file = devFile;
+      if (chainId === 31337) {
+        this.fallbackFile = path.join(MANIFEST_DEFAULT_DIR, `${defaultFallbackName}.json`);
+      } else {
+        this.fallbackFile = devFile;
+      }
+      debug('development manifest file:', this.file, 'fallback file:', this.fallbackFile);
+
+      if (devInstanceMetadata.forkedNetwork !== undefined) {
+        const forkedChainId = devInstanceMetadata.forkedNetwork.chainId;
+        debug('forked network chain id:', forkedChainId);
+
+        this.parent = new Manifest(forkedChainId);
+      }
+    } else {
+      this.dir = MANIFEST_DEFAULT_DIR;
+
+      const networkName = networkNames[chainId];
+      this.file = path.join(MANIFEST_DEFAULT_DIR, `${networkName ?? defaultFallbackName}.json`);
+      this.fallbackFile = path.join(MANIFEST_DEFAULT_DIR, `${defaultFallbackName}.json`);
+
+      debug('manifest file:', this.file, 'fallback file:', this.fallbackFile);
+    }
   }
 
   async getAdmin(): Promise<Deployment | undefined> {
@@ -143,14 +228,18 @@ export class Manifest {
     }
   }
 
-  async read(): Promise<ManifestData> {
-    const release = this.locked ? undefined : await this.lock();
+  async read(retries?: number): Promise<ManifestData> {
+    const release = this.locked ? undefined : await this.lock(retries);
     try {
       const data = JSON.parse(await this.readFile()) as ManifestData;
       return validateOrUpdateManifestVersion(data);
     } catch (e: any) {
       if (e.code === 'ENOENT') {
-        return defaultManifest();
+        if (this.parent !== undefined) {
+          return await this.parent.read(retries);
+        } else {
+          return defaultManifest();
+        }
       } else {
         throw e;
       }
@@ -179,11 +268,11 @@ export class Manifest {
     }
   }
 
-  private async lock() {
-    const lockfileName = path.join(manifestDir, `chain-${this.chainId}`);
+  private async lock(retries = 3) {
+    const lockfileName = path.join(this.dir, `chain-${this.chainIdSuffix}`);
 
     await fs.mkdir(path.dirname(lockfileName), { recursive: true });
-    const release = await lockfile.lock(lockfileName, { retries: 3, realpath: false });
+    const release = await lockfile.lock(lockfileName, { retries, realpath: false });
     this.locked = true;
     return async () => {
       await release();

package/src/provider.ts

@@ -1,7 +1,9 @@
 export interface EthereumProvider {
+  send(method: 'hardhat_metadata', params: []): Promise<HardhatMetadata>;
   send(method: 'web3_clientVersion', params: []): Promise<string>;
   send(method: 'net_version', params: []): Promise<string>;
   send(method: 'eth_chainId', params: []): Promise<string>;
+  send(method: 'eth_instanceId', params: []): Promise<string>;
   send(method: 'eth_getCode', params: [string, string]): Promise<string>;
   send(method: 'eth_call', params: unknown[]): Promise<string>;
   send(method: 'eth_getStorageAt', params: [string, string, string]): Promise<string>;
@@ -10,6 +12,15 @@ export interface EthereumProvider {
   send(method: string, params: unknown[]): Promise<unknown>;
 }
 
+interface HardhatMetadata {
+  chainId: number;
+  instanceId: string;
+  forkedNetwork?: {
+    // The chainId of the network that is being forked
+    chainId: number;
+  };
+}
+
 interface EthereumTransaction {
   blockHash: string | null;
   input: string;
@@ -38,6 +49,14 @@ export async function getClientVersion(provider: EthereumProvider): Promise<stri
   return provider.send('web3_clientVersion', []);
 }
 
+/**
+ * Gets Hardhat metadata when used with Hardhat 2.12.3 or later.
+ * The underlying provider will throw an error if this RPC method is not available.
+ */
+export async function getHardhatMetadata(provider: EthereumProvider): Promise<HardhatMetadata> {
+  return provider.send('hardhat_metadata', []);
+}
+
 export async function getStorageAt(
   provider: EthereumProvider,
   address: string,
@@ -101,10 +120,12 @@ export const networkNames: { [chainId in number]?: string } = Object.freeze({
   3: 'ropsten',
   4: 'rinkeby',
   5: 'goerli',
+  10: 'optimism',
   42: 'kovan',
   56: 'bsc',
   97: 'bsc-testnet',
   137: 'polygon',
+  420: 'optimism-goerli',
   80001: 'polygon-mumbai',
   43113: 'avalanche-fuji',
   43114: 'avalanche',
@@ -121,7 +142,7 @@ export async function isDevelopmentNetwork(provider: EthereumProvider): Promise<
   } else {
     const clientVersion = await getClientVersion(provider);
     const [name] = clientVersion.split('/', 1);
-    return name === 'HardhatNetwork' || name === 'EthereumJS TestRPC';
+    return name === 'HardhatNetwork' || name === 'EthereumJS TestRPC' || name === 'anvil';
   }
 }
 

package/src/storage/compare.ts

@@ -91,10 +91,10 @@ export function storageFieldEnd(field: StorageField): bigint | undefined {
   return begin + BigInt(numberOfBytes);
 }
 
-const LAYOUTCHANGE_COST = 0;
+const LAYOUTCHANGE_COST = 1;
 const FINISHGAP_COST = 1;
 const SHRINKGAP_COST = 0;
-const TYPECHANGE_COST = 0;
+const TYPECHANGE_COST = 1;
 
 export class StorageLayoutComparator {
   hasAllowedUncheckedCustomTypes = false;

package/src/storage/gap.ts

@@ -7,7 +7,7 @@ import { StorageField, storageFieldEnd } from './compare';
  * @returns true if field is a gap, otherwise false
  */
 export function isGap(field: StorageField): boolean {
-  return field.label === '__gap' && field.type.head === 't_array';
+  return field.type.head === 't_array' && (field.label === '__gap' || field.label.startsWith('__gap_'));
 }
 
 /**