@openzeppelin/upgrades-core 1.18.0 → 1.19.0

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

@@ -18,7 +18,6 @@ Generated by [AVA](https://avajs.dev).
       - Bad upgrade from struct StorageUpgrade_Struct_V1.Struct1 to struct StorageUpgrade_Struct_V2_Bad.Struct2Plus␊
       - In struct StorageUpgrade_Struct_V2_Bad.Struct2Plus␊
         - Added \`z\`␊
-          ␊
     ␊
     file.sol:1: Upgraded \`m\` to an incompatible type␊
       - In mapping(uint256 => struct StorageUpgrade_Struct_V2_Bad.Struct2Minus)␊
@@ -39,7 +38,6 @@ Generated by [AVA](https://avajs.dev).
         - Bad upgrade from struct StorageUpgrade_Struct_V1.Struct1 to struct StorageUpgrade_Struct_V2_Bad.Struct2Plus␊
       - In struct StorageUpgrade_Struct_V2_Bad.Struct2Plus␊
         - Added \`z\`␊
-          ␊
     ␊
     file.sol:1: Upgraded \`data3\` to an incompatible type␊
       - Bad upgrade from struct StorageUpgrade_Struct_V1.Struct1 to struct StorageUpgrade_Struct_V2_Bad.Struct2Changed␊
@@ -51,8 +49,7 @@ Generated by [AVA](https://avajs.dev).
         - Upgraded \`inner\` to an incompatible type␊
           - Bad upgrade from struct StorageUpgrade_Struct_V1.StructInner to struct StorageUpgrade_Struct_V2_Bad.StructInnerPlus␊
       - In struct StorageUpgrade_Struct_V2_Bad.StructInnerPlus␊
-        - Added \`z\`␊
-          `
+        - Added \`z\``
 
 ## enums
 

package/src/storage/report.ts

@@ -2,10 +2,20 @@ import _chalk from 'chalk';
 
 import type { BasicOperation } from '../levenshtein';
 import type { ParsedTypeDetailed } from './layout';
-import type { StorageOperation, StorageItem, StorageField, TypeChange, EnumOperation, LayoutChange } from './compare';
+import {
+  StorageOperation,
+  StorageItem,
+  StorageField,
+  TypeChange,
+  EnumOperation,
+  LayoutChange,
+  storageFieldEnd,
+  storageFieldBegin,
+} from './compare';
 import { itemize, itemizeWith } from '../utils/itemize';
 import { indent } from '../utils/indent';
 import { assert } from '../utils/assert';
+import { isGap } from './gap';
 
 export class LayoutCompatibilityReport {
   constructor(readonly ops: StorageOperation<StorageItem>[]) {}
@@ -42,10 +52,41 @@ interface StorageOperationContext {
   allowAppend: boolean;
 }
 
+interface WithHints {
+  title: string;
+  hints: string[];
+}
+
+function getExpectedGapSize(original: StorageField, updated: StorageField) {
+  const origEnd = storageFieldEnd(original);
+  const updatedStart = storageFieldBegin(updated);
+  const origNumBytes = original.type.item.numberOfBytes;
+  const origTail = original.type.tail;
+
+  if (origEnd === undefined || updatedStart === undefined || origNumBytes === undefined || origTail === undefined) {
+    return undefined;
+  }
+
+  const bytesPerItem = BigInt(origNumBytes) / BigInt(parseInt(origTail, 10));
+  const expectedSizeBytes = origEnd - updatedStart;
+
+  return expectedSizeBytes / bytesPerItem;
+}
+
+function suggestGapSize(original: StorageField, updated: StorageField): string {
+  const expectedSize = getExpectedGapSize(original, updated);
+  if (expectedSize !== undefined) {
+    return `Set __gap array to size ${expectedSize}`;
+  } else {
+    return '';
+  }
+}
+
 function explainStorageOperation(op: StorageOperation<StorageField>, ctx: StorageOperationContext): string {
   switch (op.kind) {
+    case 'shrinkgap':
     case 'typechange': {
-      const basic = explainTypeChange(op.change);
+      const basic = explainTypeChange(op.change, op.original, op.updated);
       const details =
         ctx.kind === 'layout' // explain details for layout only
           ? new Set(
@@ -54,8 +95,19 @@ function explainStorageOperation(op: StorageOperation<StorageField>, ctx: Storag
                 .filter((d?: string): d is string => d !== undefined),
             )
           : [];
-      return `Upgraded ${label(op.updated)} to an incompatible type\n` + itemize(basic, ...details);
+      const hints = [];
+      if (isGap(op.original) && op.change.kind === 'array shrink') {
+        hints.push(suggestGapSize(op.original, op.updated));
+      }
+      return printWithHints({
+        title: `Upgraded ${label(op.updated)} to an incompatible type\n` + itemize(basic, ...details),
+        hints,
+      });
     }
+
+    case 'finishgap':
+      return `Converted end of storage gap ${label(op.original)} to ${label(op.updated)}`;
+
     case 'rename':
       return `Renamed ${label(op.original)} to ${label(op.updated)}`;
 
@@ -63,11 +115,17 @@ function explainStorageOperation(op: StorageOperation<StorageField>, ctx: Storag
       return `Replaced ${label(op.original)} with ${label(op.updated)} of incompatible type`;
 
     case 'layoutchange': {
-      return (
+      const title =
         `Layout ${op.change.uncertain ? 'could have changed' : 'changed'} for ${label(op.updated)} ` +
         `(${op.original.type.item.label} -> ${op.updated.type.item.label})\n` +
-        describeLayoutTransition(op.change)
-      ).trimEnd();
+        describeLayoutTransition(op.change);
+      const hints = [];
+
+      if (isGap(op.original)) {
+        hints.push(suggestGapSize(op.original, op.updated));
+      }
+
+      return printWithHints({ title, hints });
     }
 
     default: {
@@ -94,12 +152,16 @@ function explainStorageOperation(op: StorageOperation<StorageField>, ctx: Storag
         }
       }
 
-      return title + '\n' + itemizeWith('>', ...hints);
+      return printWithHints({ title, hints });
     }
   }
 }
 
-function explainTypeChange(ch: TypeChange): string {
+function printWithHints(result: WithHints): string {
+  return (result.title + '\n' + itemizeWith('>', ...result.hints)).trimEnd();
+}
+
+function explainTypeChange(ch: TypeChange, original: StorageField, updated: StorageField): string {
   switch (ch.kind) {
     case 'visibility change':
       return `Bad upgrade ${describeTransition(ch.original, ch.updated)}\nDifferent visibility`;
@@ -113,19 +175,28 @@ function explainTypeChange(ch: TypeChange): string {
       return `Bad upgrade ${describeTransition(ch.original, ch.updated)}\nDifferent representation sizes`;
 
     case 'mapping key':
-      return `In key of ${ch.updated.item.label}\n` + itemize(explainTypeChange(ch.inner));
+      return `In key of ${ch.updated.item.label}\n` + itemize(explainTypeChange(ch.inner, original, updated));
 
     case 'mapping value':
     case 'array value':
-      return `In ${ch.updated.item.label}\n` + itemize(explainTypeChange(ch.inner));
+      return `In ${ch.updated.item.label}\n` + itemize(explainTypeChange(ch.inner, original, updated));
 
     case 'array shrink':
     case 'array grow': {
       assert(ch.original.tail && ch.updated.tail);
       const originalSize = parseInt(ch.original.tail, 10);
       const updatedSize = parseInt(ch.updated.tail, 10);
-      const note = ch.kind === 'array shrink' ? 'Size cannot decrease' : 'Size cannot increase here';
-      return `Bad array resize from ${originalSize} to ${updatedSize}\n${note}`;
+
+      if (isGap(original)) {
+        const note =
+          ch.kind === 'array shrink'
+            ? 'Size decrease must match with corresponding variable inserts'
+            : 'Size cannot increase';
+        return `Bad storage gap resize from ${originalSize} to ${updatedSize}\n${note}`;
+      } else {
+        const note = ch.kind === 'array shrink' ? 'Size cannot decrease' : 'Size cannot increase here';
+        return `Bad array resize from ${originalSize} to ${updatedSize}\n${note}`;
+      }
     }
 
     case 'array dynamic': {

package/src/storage.test.ts

@@ -65,7 +65,7 @@ test('storage upgrade delete', t => {
   const v2 = t.context.extractStorageLayout('StorageUpgrade_Delete_V2');
   const comparison = getStorageUpgradeErrors(v1, v2);
   t.like(comparison, {
-    length: 1,
+    length: 2,
     0: {
       kind: 'delete',
       original: {
@@ -76,6 +76,23 @@ test('storage upgrade delete', t => {
         },
       },
     },
+    1: {
+      kind: 'layoutchange',
+      original: {
+        label: 'x2',
+        type: {
+          id: 't_address',
+        },
+        slot: '1',
+      },
+      updated: {
+        label: 'x2',
+        type: {
+          id: 't_address',
+        },
+        slot: '0',
+      },
+    },
   });
 });
 
@@ -172,6 +189,7 @@ test('storage upgrade with structs', t => {
   t.deepEqual(getStorageUpgradeErrors(v1, v2_Ok), []);
 
   const v2_Bad = t.context.extractStorageLayout('StorageUpgrade_Struct_V2_Bad');
+
   t.like(getStorageUpgradeErrors(v1, v2_Bad), {
     length: 6,
     0: {
@@ -179,7 +197,7 @@ test('storage upgrade with structs', t => {
       change: {
         kind: 'struct members',
         ops: {
-          length: 2,
+          length: 3,
           0: { kind: 'delete' },
         },
       },
@@ -474,6 +492,452 @@ test('storage upgrade with embedded enum inside struct type', t => {
   t.deepEqual(getStorageUpgradeErrors(v1, v2), []);
 });
 
+test('storage upgrade with gap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Gap_V1');
+  const v2_Ok = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Ok');
+
+  const v2_Bad1 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Bad1');
+  const v2_Bad2 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Bad2');
+  const v2_Bad3 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Bad3');
+  const v2_Bad4 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Bad4');
+  const v2_Bad5 = t.context.extractStorageLayout('StorageUpgrade_Gap_V2_Bad5');
+
+  t.deepEqual(getStorageUpgradeErrors(v1, v2_Ok), []);
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad1), {
+    length: 2,
+    0: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '2',
+          to: '3',
+        },
+      },
+      original: { label: '__gap' },
+      updated: { label: '__gap' },
+    },
+    1: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '50',
+          to: '51',
+        },
+      },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad2), {
+    length: 2,
+    0: {
+      kind: 'delete',
+      original: { label: 'b' },
+    },
+    1: {
+      kind: 'typechange',
+      change: { kind: 'array grow' },
+    },
+  });
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad3), {
+    length: 2,
+    0: {
+      kind: 'typechange',
+      change: { kind: 'array shrink' },
+    },
+    1: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '50',
+          to: '49',
+        },
+      },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad4), {
+    length: 2,
+    0: {
+      kind: 'typechange',
+      change: { kind: 'array shrink' },
+    },
+    1: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '50',
+          to: '49',
+        },
+      },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad5), {
+    length: 2,
+    0: {
+      kind: 'typechange',
+      change: { kind: 'array shrink' },
+      original: { label: '__gap' },
+      updated: { label: '__gap' },
+    },
+    1: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '50',
+          to: '51',
+        },
+      },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+});
+
+test('storage upgrade with bytes32 gap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Bytes32Gap_V1');
+  const v2_Ok = t.context.extractStorageLayout('StorageUpgrade_Bytes32Gap_V2_Ok');
+
+  const v2_Bad1 = t.context.extractStorageLayout('StorageUpgrade_Bytes32Gap_V2_Bad1');
+  const v2_Bad2 = t.context.extractStorageLayout('StorageUpgrade_Bytes32Gap_V2_Bad2');
+  const v2_Bad3 = t.context.extractStorageLayout('StorageUpgrade_Bytes32Gap_V2_Bad3');
+  const v2_Bad4 = t.context.extractStorageLayout('StorageUpgrade_Bytes32Gap_V2_Bad4');
+  const v2_Bad5 = t.context.extractStorageLayout('StorageUpgrade_Bytes32Gap_V2_Bad5');
+
+  t.deepEqual(getStorageUpgradeErrors(v1, v2_Ok), []);
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad1), {
+    length: 2,
+    0: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '2',
+          to: '3',
+        },
+      },
+      original: { label: '__gap' },
+      updated: { label: '__gap' },
+    },
+    1: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '50',
+          to: '51',
+        },
+      },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad2), {
+    length: 2,
+    0: {
+      kind: 'delete',
+      original: { label: 'b' },
+    },
+    1: {
+      kind: 'typechange',
+      change: { kind: 'array grow' },
+    },
+  });
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad3), {
+    length: 2,
+    0: {
+      kind: 'typechange',
+      change: { kind: 'array shrink' },
+    },
+    1: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '50',
+          to: '49',
+        },
+      },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad4), {
+    length: 2,
+    0: {
+      kind: 'typechange',
+      change: { kind: 'array shrink' },
+    },
+    1: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '50',
+          to: '49',
+        },
+      },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad5), {
+    length: 2,
+    0: {
+      kind: 'typechange',
+      change: { kind: 'array shrink' },
+      original: { label: '__gap' },
+      updated: { label: '__gap' },
+    },
+    1: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '50',
+          to: '51',
+        },
+      },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+});
+
+test('storage upgrade with multiple items consuming a gap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_MultiConsumeGap_V1');
+  const v2_Ok = t.context.extractStorageLayout('StorageUpgrade_MultiConsumeGap_V2_Ok');
+
+  t.deepEqual(getStorageUpgradeErrors(v1, v2_Ok), []);
+});
+
+test('storage upgrade that consumes gap and inherited gap', t => {
+  const v1a = t.context.extractStorageLayout('StorageUpgrade_EndGap_V1a');
+  const v1b = t.context.extractStorageLayout('StorageUpgrade_EndGap_V1b');
+  const v1c = t.context.extractStorageLayout('StorageUpgrade_EndGap_V1c');
+  const v2a = t.context.extractStorageLayout('StorageUpgrade_EndGap_V2a');
+  const v2b = t.context.extractStorageLayout('StorageUpgrade_EndGap_V2b');
+
+  t.deepEqual(getStorageUpgradeErrors(v1a, v2a), []);
+
+  t.like(getStorageUpgradeErrors(v1b, v2a), {
+    length: 1,
+    0: {
+      kind: 'delete',
+      original: { label: '__gap' },
+    },
+  });
+
+  t.like(getStorageUpgradeErrors(v1c, v2a), {
+    length: 2,
+    0: {
+      kind: 'delete',
+      original: { label: '__gap' },
+    },
+    1: {
+      kind: 'delete',
+      original: { label: 'b' },
+    },
+  });
+
+  t.deepEqual(getStorageUpgradeErrors(v1b, v2b), []);
+});
+
+test('storage upgrade that consumes gap and inherited gap with smaller data type', t => {
+  const v1a = t.context.extractStorageLayout('StorageUpgrade_EndGap_Uint128_V1a');
+  const v1b = t.context.extractStorageLayout('StorageUpgrade_EndGap_Uint128_V1b');
+  const v1c = t.context.extractStorageLayout('StorageUpgrade_EndGap_Uint128_V1c');
+  const v2a = t.context.extractStorageLayout('StorageUpgrade_EndGap_Uint128_V2a');
+  const v2b = t.context.extractStorageLayout('StorageUpgrade_EndGap_Uint128_V2b');
+
+  t.deepEqual(getStorageUpgradeErrors(v1a, v2a), []);
+
+  t.like(getStorageUpgradeErrors(v1b, v2a), {
+    length: 1,
+    0: {
+      kind: 'delete',
+      original: { label: '__gap' },
+    },
+  });
+
+  t.like(getStorageUpgradeErrors(v1c, v2a), {
+    length: 2,
+    0: {
+      kind: 'delete',
+      original: { label: '__gap' },
+    },
+    1: {
+      kind: 'delete',
+      original: { label: 'b' },
+    },
+  });
+
+  t.deepEqual(getStorageUpgradeErrors(v1b, v2b), []);
+});
+
+test('storage upgrade with different typed gaps', t => {
+  const uint256gap_address_v1 = t.context.extractStorageLayout('StorageUpgrade_Uint256Gap_Address_V1');
+  const uint256gap_address_v2 = t.context.extractStorageLayout('StorageUpgrade_Uint256Gap_Address_V2');
+
+  const address_v1 = t.context.extractStorageLayout('StorageUpgrade_AddressGap_V1');
+  const address_v2 = t.context.extractStorageLayout('StorageUpgrade_AddressGap_V2');
+
+  const uint128_v1 = t.context.extractStorageLayout('StorageUpgrade_Uint128Gap_V1');
+  const uint128_v2_ok = t.context.extractStorageLayout('StorageUpgrade_Uint128Gap_V2_Ok');
+  const uint128_v2b_ok = t.context.extractStorageLayout('StorageUpgrade_Uint128Gap_V2b_Ok');
+  const uint128_v2_bad = t.context.extractStorageLayout('StorageUpgrade_Uint128Gap_V2_Bad');
+
+  const bool_v1 = t.context.extractStorageLayout('StorageUpgrade_BoolGap_V1');
+  const bool_v2_ok = t.context.extractStorageLayout('StorageUpgrade_BoolGap_V2_Ok');
+  const bool_v2_bad = t.context.extractStorageLayout('StorageUpgrade_BoolGap_V2_Bad');
+
+  t.deepEqual(getStorageUpgradeErrors(uint256gap_address_v1, uint256gap_address_v2), []);
+  t.deepEqual(getStorageUpgradeErrors(address_v1, address_v2), []);
+
+  t.deepEqual(getStorageUpgradeErrors(uint128_v1, uint128_v2_ok), []);
+  t.deepEqual(getStorageUpgradeErrors(uint128_v1, uint128_v2b_ok), []);
+
+  t.like(getStorageUpgradeErrors(uint128_v1, uint128_v2_bad), {
+    length: 2,
+    0: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '1',
+          to: '2',
+        },
+      },
+      original: { label: '__gap' },
+      updated: { label: '__gap' },
+    },
+    1: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '26',
+          to: '27',
+        },
+      },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+
+  t.deepEqual(getStorageUpgradeErrors(bool_v1, bool_v2_ok), []);
+  t.like(getStorageUpgradeErrors(bool_v1, bool_v2_bad), {
+    length: 2,
+    0: {
+      kind: 'typechange',
+      change: { kind: 'array shrink' },
+      original: { label: '__gap' },
+      updated: { label: '__gap' },
+    },
+    1: {
+      kind: 'typechange',
+      change: { kind: 'obvious mismatch' },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+});
+
+test('storage upgrade with one element gap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Gap_One_Element_V1');
+  const v2_Ok = t.context.extractStorageLayout('StorageUpgrade_Gap_One_Element_V2_Ok');
+  const v2b_Ok = t.context.extractStorageLayout('StorageUpgrade_Gap_One_Element_V2b_Ok');
+  const v2_Bad = t.context.extractStorageLayout('StorageUpgrade_Gap_One_Element_V2_Bad');
+
+  t.deepEqual(getStorageUpgradeErrors(v1, v2_Ok), []);
+  t.deepEqual(getStorageUpgradeErrors(v1, v2b_Ok), []);
+  t.like(getStorageUpgradeErrors(v1, v2_Bad), {
+    length: 2,
+    0: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '2',
+          to: '3',
+        },
+      },
+      original: { label: '__gap' },
+      updated: { label: '__gap' },
+    },
+    1: {
+      kind: 'layoutchange',
+      change: {
+        slot: {
+          from: '3',
+          to: '4',
+        },
+      },
+      original: { label: 'z' },
+      updated: { label: 'z' },
+    },
+  });
+});
+
+test('storage upgrade with bool non-array named as __gap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Gap_Bool_Not_Array_V1');
+  const v2_Bad = t.context.extractStorageLayout('StorageUpgrade_Gap_Bool_Not_Array_V2_Bad');
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad), {
+    length: 1,
+    0: {
+      kind: 'rename',
+      original: { label: '__gap' },
+      updated: { label: 'c' },
+    },
+  });
+});
+
+test('storage upgrade with uint256 non-array named as __gap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_Gap_Uint256_Not_Array_V1');
+  const v2_Bad = t.context.extractStorageLayout('StorageUpgrade_Gap_Uint256_Not_Array_V2_Bad');
+
+  t.like(getStorageUpgradeErrors(v1, v2_Bad), {
+    length: 1,
+    0: {
+      kind: 'rename',
+      original: { label: '__gap' },
+      updated: { label: 'c' },
+    },
+  });
+});
+
+test('storage upgrade with struct gap', t => {
+  const v1 = t.context.extractStorageLayout('StorageUpgrade_StructGap_V1');
+  const v2_Ok = t.context.extractStorageLayout('StorageUpgrade_StructGap_V2_Ok');
+  const v2_Bad = t.context.extractStorageLayout('StorageUpgrade_StructGap_V2_Bad');
+
+  t.deepEqual(getStorageUpgradeErrors(v1, v2_Ok), []);
+  t.like(getStorageUpgradeErrors(v1, v2_Bad), {
+    length: 3,
+    0: {
+      kind: 'typechange',
+      original: { label: 'store_mapping' },
+      updated: { label: 'store_mapping' },
+    },
+    1: {
+      kind: 'typechange',
+      original: { label: 'store_fixed_array' },
+      updated: { label: 'store_fixed_array' },
+    },
+    2: {
+      kind: 'typechange',
+      original: { label: 'store_dynamic_array' },
+      updated: { label: 'store_dynamic_array' },
+    },
+  });
+});
+
 function stabilizeStorageLayout(layout: StorageLayout) {
   return {
     storage: layout.storage.map(s => ({ ...s, type: stabilizeTypeIdentifier(s.type) })),

package/src/validate/data.ts

@@ -1,4 +1,4 @@
-import versions from 'compare-versions';
+import * as versions from 'compare-versions';
 
 import { ValidationRunData } from './run';