@openzeppelin/upgrades-core 1.19.1 → 1.20.1

package/src/storage.test.ts

@@ -6,9 +6,10 @@ import { artifacts } from 'hardhat';
 import { SolcOutput } from './solc-api';
 import { astDereferencer } from './ast-dereferencer';
 import { getStorageUpgradeErrors } from './storage';
-import { StorageLayout, isEnumMembers } from './storage/layout';
+import { StorageLayout } from './storage/layout';
 import { extractStorageLayout } from './storage/extract';
 import { stabilizeTypeIdentifier } from './utils/type-id';
+import { stabilizeStorageLayout } from './utils/stabilize-layout';
 
 interface Context {
   extractStorageLayout: (contract: string) => ReturnType<typeof extractStorageLayout>;
@@ -331,7 +332,7 @@ test('storage upgrade with enums', t => {
     },
     3: {
       kind: 'typechange',
-      change: { kind: 'enum resize' },
+      change: { kind: 'type resize' },
       original: { label: 'data4' },
       updated: { label: 'data4' },
     },
@@ -937,17 +938,3 @@ test('storage upgrade with struct gap', t => {
     },
   });
 });
-
-function stabilizeStorageLayout(layout: StorageLayout) {
-  return {
-    storage: layout.storage.map(s => ({ ...s, type: stabilizeTypeIdentifier(s.type) })),
-    types: Object.entries(layout.types).map(([type, item]) => {
-      const members =
-        item.members &&
-        (isEnumMembers(item.members)
-          ? item.members
-          : item.members.map(m => ({ ...m, type: stabilizeTypeIdentifier(m.type) })));
-      return [stabilizeTypeIdentifier(type), { ...item, members }];
-    }),
-  };
-}

package/src/utils/function.ts

@@ -1,8 +1,8 @@
-import type { FunctionDefinition, VariableDeclaration } from 'solidity-ast';
+import type { FunctionDefinition, TypeName, VariableDeclaration } from 'solidity-ast';
 import { ASTDereferencer } from '../ast-dereferencer';
 import { assert, assertUnreachable } from './assert';
 
-function serializeTypeName(parameter: VariableDeclaration, deref: ASTDereferencer): string {
+function serializeParameterType(parameter: VariableDeclaration, deref: ASTDereferencer): string {
   const { typeName, storageLocation } = parameter;
   assert(!!typeName);
 
@@ -11,6 +11,10 @@ function serializeTypeName(parameter: VariableDeclaration, deref: ASTDereference
     return typeName.typeDescriptions.typeString.replace(/^struct /, '') + ' storage';
   }
 
+  return serializeTypeName(typeName, deref);
+}
+
+function serializeTypeName(typeName: TypeName, deref: ASTDereferencer): string {
   switch (typeName.nodeType) {
     case 'ArrayTypeName':
     case 'ElementaryTypeName': {
@@ -20,12 +24,12 @@ function serializeTypeName(parameter: VariableDeclaration, deref: ASTDereference
 
     case 'UserDefinedTypeName': {
       const userDefinedType = deref(
-        ['StructDefinition', 'EnumDefinition', 'ContractDefinition'],
+        ['StructDefinition', 'EnumDefinition', 'ContractDefinition', 'UserDefinedValueTypeDefinition'],
         typeName.referencedDeclaration,
       );
       switch (userDefinedType.nodeType) {
         case 'StructDefinition':
-          return '(' + userDefinedType.members.map(member => serializeTypeName(member, deref)) + ')';
+          return '(' + userDefinedType.members.map(member => serializeParameterType(member, deref)) + ')';
 
         case 'EnumDefinition':
           assert(userDefinedType.members.length < 256);
@@ -34,6 +38,9 @@ function serializeTypeName(parameter: VariableDeclaration, deref: ASTDereference
         case 'ContractDefinition':
           return 'address';
 
+        case 'UserDefinedValueTypeDefinition':
+          return serializeTypeName(userDefinedType.underlyingType, deref);
+
         default:
           return assertUnreachable(userDefinedType);
       }
@@ -49,5 +56,7 @@ function serializeTypeName(parameter: VariableDeclaration, deref: ASTDereference
 }
 
 export function getFunctionSignature(fnDef: FunctionDefinition, deref: ASTDereferencer): string {
-  return `${fnDef.name}(${fnDef.parameters.parameters.map(parameter => serializeTypeName(parameter, deref)).join()})`;
+  return `${fnDef.name}(${fnDef.parameters.parameters
+    .map(parameter => serializeParameterType(parameter, deref))
+    .join()})`;
 }

package/src/utils/stabilize-layout.ts

@@ -0,0 +1,17 @@
+import { StorageLayout } from '../storage';
+import { isEnumMembers } from '../storage/layout';
+import { stabilizeTypeIdentifier } from './type-id';
+
+export function stabilizeStorageLayout(layout: StorageLayout) {
+  return {
+    storage: layout.storage.map(s => ({ ...s, type: stabilizeTypeIdentifier(s.type) })),
+    types: Object.entries(layout.types).map(([type, item]) => {
+      const members =
+        item.members &&
+        (isEnumMembers(item.members)
+          ? item.members
+          : item.members.map(m => ({ ...m, type: stabilizeTypeIdentifier(m.type) })));
+      return [stabilizeTypeIdentifier(type), { ...item, members }];
+    }),
+  };
+}

package/src/utils/type-id.ts

@@ -35,7 +35,7 @@ export function normalizeTypeIdentifier(typeIdentifier: string): string {
 // identifier by removing all AST ids.
 export function stabilizeTypeIdentifier(typeIdentifier: string): string {
   let decoded = decodeTypeIdentifier(typeIdentifier);
-  const re = /(t_struct|t_enum|t_contract)\(/g;
+  const re = /(t_struct|t_enum|t_contract|t_userDefinedValueType)\(/g;
   let match;
   while ((match = re.exec(decoded))) {
     let i;

package/src/validate/data.ts

@@ -7,10 +7,10 @@ type ValidationDataV1 = ValidationRunData;
 type ValidationDataV2 = ValidationRunData[];
 
 const currentMajor = '3';
-const currentVersion = '3.2';
+const currentVersion = '3.3';
 
 interface ValidationDataV3 {
-  version: '3' | '3.1' | '3.2';
+  version: '3' | '3.1' | '3.2' | '3.3';
   log: ValidationRunData[];
 }
 

package/src/validate/query.ts

@@ -58,11 +58,16 @@ export function getStorageLayout(data: ValidationData, version: Version): Storag
 }
 
 export function unfoldStorageLayout(runData: ValidationRunData, contractName: string): StorageLayout {
-  const layout: StorageLayout = { storage: [], types: {} };
-  if (runData[contractName].layout.flat) {
-    return { storage: runData[contractName].layout.storage, types: runData[contractName].layout.types };
+  const c = runData[contractName];
+  const { solcVersion } = c;
+  if (c.layout.flat) {
+    return {
+      solcVersion,
+      storage: c.layout.storage,
+      types: c.layout.types,
+    };
   } else {
-    const c = runData[contractName];
+    const layout: StorageLayout = { solcVersion, storage: [], types: {} };
     for (const name of [contractName].concat(c.inherit)) {
       layout.storage.unshift(...runData[name].layout.storage);
       Object.assign(layout.types, runData[name].layout.types);

package/src/validate/run.ts

@@ -23,6 +23,7 @@ export interface ContractValidation {
   linkReferences: LinkReference[];
   errors: ValidationError[];
   layout: StorageLayout;
+  solcVersion?: string;
 }
 
 const errorKinds = [
@@ -113,7 +114,7 @@ function skipCheck(error: string, node: Node): boolean {
   return getAllowed(node).includes(error);
 }
 
-export function validate(solcOutput: SolcOutput, decodeSrc: SrcDecoder): ValidationRunData {
+export function validate(solcOutput: SolcOutput, decodeSrc: SrcDecoder, solcVersion?: string): ValidationRunData {
   const validation: ValidationRunData = {};
   const fromId: Record<number, string> = {};
   const inheritIds: Record<string, number[]> = {};
@@ -139,6 +140,7 @@ export function validate(solcOutput: SolcOutput, decodeSrc: SrcDecoder): Validat
           storage: [],
           types: {},
         },
+        solcVersion,
       };
     }
 

package/src/validate.test.ts

@@ -22,6 +22,7 @@ test.before(async t => {
     'contracts/test/Validations.sol:HasEmptyConstructor',
     'contracts/test/ValidationsNatspec.sol:HasNonEmptyConstructorNatspec1',
     'contracts/test/Proxiable.sol:ChildOfProxiable',
+    'contracts/test/ValidationsUDVT.sol:ValidationsUDVT',
   ];
 
   t.context.validation = {} as RunValidation;