@openzeppelin/upgrades-core 1.20.3 → 1.20.5

package/src/validate/query.ts

@@ -11,54 +11,81 @@ const upgradeToSignature = 'upgradeTo(address)';
 
 export function assertUpgradeSafe(data: ValidationData, version: Version, opts: ValidationOptions): void {
   const dataV3 = normalizeValidationData(data);
-  const [contractName] = getContractNameAndRunValidation(dataV3, version);
+  const [fullContractName] = getContractNameAndRunValidation(dataV3, version);
 
   const errors = getErrors(dataV3, version, opts);
 
   if (errors.length > 0) {
-    throw new ValidationErrors(contractName, errors);
+    throw new ValidationErrors(fullContractName, errors);
   }
 }
 
+/**
+ * Gets the contract version object from the given validation run data and contract name (either fully qualified or simple contract name).
+ *
+ * @param runData The validation run data
+ * @param contractName Fully qualified or simple contract name
+ * @returns contract version object
+ * @throws {Error} if the given contract name is not found or is ambiguous
+ */
 export function getContractVersion(runData: ValidationRunData, contractName: string): Version {
-  const { version } = runData[contractName];
+  let version = undefined;
+  if (contractName.includes(':')) {
+    version = runData[contractName].version;
+  } else {
+    const foundNames = Object.keys(runData).filter(element => element.endsWith(`:${contractName}`));
+    if (foundNames.length > 1) {
+      throw new Error(`Contract ${contractName} is ambiguous. Use one of the following:\n${foundNames.join('\n')}`);
+    } else if (foundNames.length === 1) {
+      version = runData[foundNames[0]].version;
+    }
+  }
+
   if (version === undefined) {
     throw new Error(`Contract ${contractName} is abstract`);
   }
+
   return version;
 }
 
+/**
+ * Gets the fully qualified contract name and validation run data.
+ *
+ * @param data The validation data
+ * @param version The contract Version
+ * @returns fully qualified contract name and validation run data
+ */
 export function getContractNameAndRunValidation(data: ValidationData, version: Version): [string, ValidationRunData] {
   const dataV3 = normalizeValidationData(data);
 
   let runValidation;
-  let contractName;
+  let fullContractName;
 
   for (const validation of dataV3.log) {
-    contractName = Object.keys(validation).find(
+    fullContractName = Object.keys(validation).find(
       name => validation[name].version?.withMetadata === version.withMetadata,
     );
-    if (contractName !== undefined) {
+    if (fullContractName !== undefined) {
       runValidation = validation;
       break;
     }
   }
 
-  if (contractName === undefined || runValidation === undefined) {
+  if (fullContractName === undefined || runValidation === undefined) {
     throw new Error('The requested contract was not found. Make sure the source code is available for compilation');
   }
 
-  return [contractName, runValidation];
+  return [fullContractName, runValidation];
 }
 
 export function getStorageLayout(data: ValidationData, version: Version): StorageLayout {
   const dataV3 = normalizeValidationData(data);
-  const [contractName, runValidation] = getContractNameAndRunValidation(dataV3, version);
-  return unfoldStorageLayout(runValidation, contractName);
+  const [fullContractName, runValidation] = getContractNameAndRunValidation(dataV3, version);
+  return unfoldStorageLayout(runValidation, fullContractName);
 }
 
-export function unfoldStorageLayout(runData: ValidationRunData, contractName: string): StorageLayout {
-  const c = runData[contractName];
+export function unfoldStorageLayout(runData: ValidationRunData, fullContractName: string): StorageLayout {
+  const c = runData[fullContractName];
   const { solcVersion } = c;
   if (c.layout.flat) {
     return {
@@ -68,7 +95,7 @@ export function unfoldStorageLayout(runData: ValidationRunData, contractName: st
     };
   } else {
     const layout: StorageLayout = { solcVersion, storage: [], types: {} };
-    for (const name of [contractName].concat(c.inherit)) {
+    for (const name of [fullContractName].concat(c.inherit)) {
       layout.storage.unshift(...runData[name].layout.storage);
       Object.assign(layout.types, runData[name].layout.types);
     }
@@ -113,12 +140,14 @@ export function getUnlinkedBytecode(data: ValidationData, bytecode: string): str
 
 export function getErrors(data: ValidationData, version: Version, opts: ValidationOptions = {}): ValidationError[] {
   const dataV3 = normalizeValidationData(data);
-  const [contractName, runValidation] = getContractNameAndRunValidation(dataV3, version);
-  const c = runValidation[contractName];
+  const [fullContractName, runValidation] = getContractNameAndRunValidation(dataV3, version);
+  const c = runValidation[fullContractName];
 
-  const errors = getUsedContractsAndLibraries(contractName, runValidation).flatMap(name => runValidation[name].errors);
+  const errors = getUsedContractsAndLibraries(fullContractName, runValidation).flatMap(
+    name => runValidation[name].errors,
+  );
 
-  const selfAndInheritedMethods = getAllMethods(runValidation, contractName);
+  const selfAndInheritedMethods = getAllMethods(runValidation, fullContractName);
 
   if (!selfAndInheritedMethods.includes(upgradeToSignature)) {
     errors.push({
@@ -127,11 +156,11 @@ export function getErrors(data: ValidationData, version: Version, opts: Validati
     });
   }
 
-  return processExceptions(contractName, errors, opts);
+  return processExceptions(fullContractName, errors, opts);
 }
 
-function getAllMethods(runValidation: ValidationRunData, contractName: string): string[] {
-  const c = runValidation[contractName];
+function getAllMethods(runValidation: ValidationRunData, fullContractName: string): string[] {
+  const c = runValidation[fullContractName];
   return c.methods.concat(...c.inherit.map(name => runValidation[name].methods));
 }
 
@@ -155,8 +184,8 @@ export function isUpgradeSafe(data: ValidationData, version: Version): boolean {
 
 export function inferProxyKind(data: ValidationData, version: Version): ProxyDeployment['kind'] {
   const dataV3 = normalizeValidationData(data);
-  const [contractName, runValidation] = getContractNameAndRunValidation(dataV3, version);
-  const methods = getAllMethods(runValidation, contractName);
+  const [fullContractName, runValidation] = getContractNameAndRunValidation(dataV3, version);
+  const methods = getAllMethods(runValidation, fullContractName);
   if (methods.includes(upgradeToSignature)) {
     return 'uups';
   } else {

package/src/validate/run.ts

@@ -114,6 +114,10 @@ function skipCheck(error: string, node: Node): boolean {
   return getAllowed(node).includes(error);
 }
 
+function getFullyQualifiedName(source: string, contractName: string) {
+  return `${source}:${contractName}`;
+}
+
 export function validate(solcOutput: SolcOutput, decodeSrc: SrcDecoder, solcVersion?: string): ValidationRunData {
   const validation: ValidationRunData = {};
   const fromId: Record<number, string> = {};
@@ -128,7 +132,7 @@ export function validate(solcOutput: SolcOutput, decodeSrc: SrcDecoder, solcVers
       const version = bytecode.object === '' ? undefined : getVersion(bytecode.object);
       const linkReferences = extractLinkReferences(bytecode);
 
-      validation[contractName] = {
+      validation[getFullyQualifiedName(source, contractName)] = {
         src: contractName,
         version,
         inherit: [],
@@ -145,17 +149,19 @@ export function validate(solcOutput: SolcOutput, decodeSrc: SrcDecoder, solcVers
     }
 
     for (const contractDef of findAll('ContractDefinition', solcOutput.sources[source].ast)) {
-      fromId[contractDef.id] = contractDef.name;
+      const key = getFullyQualifiedName(source, contractDef.name);
+
+      fromId[contractDef.id] = key;
 
       // May be undefined in case of duplicate contract names in Truffle
       const bytecode = solcOutput.contracts[source][contractDef.name]?.evm.bytecode;
 
-      if (contractDef.name in validation && bytecode !== undefined) {
-        inheritIds[contractDef.name] = contractDef.linearizedBaseContracts.slice(1);
-        libraryIds[contractDef.name] = getReferencedLibraryIds(contractDef);
+      if (key in validation && bytecode !== undefined) {
+        inheritIds[key] = contractDef.linearizedBaseContracts.slice(1);
+        libraryIds[key] = getReferencedLibraryIds(contractDef);
 
-        validation[contractDef.name].src = decodeSrc(contractDef);
-        validation[contractDef.name].errors = [
+        validation[key].src = decodeSrc(contractDef);
+        validation[key].errors = [
           ...getConstructorErrors(contractDef, decodeSrc),
           ...getOpcodeErrors(contractDef, decodeSrc),
           ...getStateVariableErrors(contractDef, decodeSrc),
@@ -164,25 +170,25 @@ export function validate(solcOutput: SolcOutput, decodeSrc: SrcDecoder, solcVers
           ...getLinkingErrors(contractDef, bytecode),
         ];
 
-        validation[contractDef.name].layout = extractStorageLayout(
+        validation[key].layout = extractStorageLayout(
           contractDef,
           decodeSrc,
           deref,
           solcOutput.contracts[source][contractDef.name].storageLayout,
         );
-        validation[contractDef.name].methods = [...findAll('FunctionDefinition', contractDef)]
+        validation[key].methods = [...findAll('FunctionDefinition', contractDef)]
           .filter(fnDef => ['external', 'public'].includes(fnDef.visibility))
           .map(fnDef => getFunctionSignature(fnDef, deref));
       }
     }
   }
 
-  for (const contractName in inheritIds) {
-    validation[contractName].inherit = inheritIds[contractName].map(id => fromId[id]);
+  for (const key in inheritIds) {
+    validation[key].inherit = inheritIds[key].map(id => fromId[id]);
   }
 
-  for (const contractName in libraryIds) {
-    validation[contractName].libraries = libraryIds[contractName].map(id => fromId[id]);
+  for (const key in libraryIds) {
+    validation[key].libraries = libraryIds[key].map(id => fromId[id]);
   }
 
   return validation;

package/src/validate.test.ts

@@ -133,3 +133,16 @@ testValid('UsesExplicitSafeExternalLibraryNatspec', 'transparent', true);
 testValid('UsesExplicitUnsafeInternalLibraryNatspec', 'transparent', true);
 testValid('UsesExplicitUnsafeExternalLibraryNatspec', 'transparent', true);
 testValid('TransitiveLibraryIsUnsafe', 'transparent', false);
+
+testValid('contracts/test/ValidationsSameNameSafe.sol:SameName', 'transparent', true);
+testValid('contracts/test/ValidationsSameNameUnsafe.sol:SameName', 'transparent', false);
+
+test('ambiguous name', t => {
+  const error = t.throws(() => getContractVersion(t.context.validation, 'SameName'));
+  t.is(
+    error?.message,
+    'Contract SameName is ambiguous. Use one of the following:\n' +
+      'contracts/test/ValidationsSameNameSafe.sol:SameName\n' +
+      'contracts/test/ValidationsSameNameUnsafe.sol:SameName',
+  );
+});