@openzeppelin/upgrades-core 1.41.0 → 1.42.1

package/src/validate/run/initializer.ts

@@ -0,0 +1,316 @@
+import type { ContractDefinition, FunctionDefinition } from 'solidity-ast';
+import { ASTDereferencer, findAll } from 'solidity-ast/utils';
+import { SrcDecoder } from '../../src-decoder';
+import { ValidationExceptionInitializer, skipCheck } from '../run';
+
+/**
+ * Reports if this contract is non-abstract and any of the following are true:
+ * - 1. Missing initializer: This contract does not appear to have an initializer, but parent contracts require initialization.
+ * - 2. Missing initializer call: This contract's initializer is missing a call to a parent initializer.
+ * - 3. Duplicate initializer call: This contract has duplicate calls to the same parent initializer function.
+ * - 4. Incorrect initializer order (warning): This contract does not call parent initializers in the correct order.
+ */
+export function* getInitializerExceptions(
+  contractDef: ContractDefinition,
+  deref: ASTDereferencer,
+  decodeSrc: SrcDecoder,
+): Generator<ValidationExceptionInitializer> {
+  if (contractDef.abstract) {
+    return;
+  }
+
+  const linearizedParentContracts = getLinearizedParentContracts(contractDef, deref);
+  const parentNameToInitializersMap = getParentNameToInitializersMap(linearizedParentContracts);
+
+  const remainingParents = getParentsNotInitializedByOtherParents(parentNameToInitializersMap);
+
+  if (remainingParents.length > 0) {
+    const contractInitializers = getPossibleInitializers(contractDef, false);
+
+    // Report if there is no initializer but parents need initialization
+    if (
+      checkNeedsInitialization(remainingParents, parentNameToInitializersMap) &&
+      contractInitializers.length === 0 &&
+      !skipCheck('missing-initializer', contractDef)
+    ) {
+      yield {
+        kind: 'missing-initializer',
+        src: decodeSrc(contractDef),
+      };
+    }
+
+    // Linearized list of parent contracts that have initializers
+    const expectedLinearized: string[] = [...parentNameToInitializersMap.keys()];
+
+    // The parent contracts that need to be directly initialized by this contract, which excludes parents that are initialized by other parents.
+    // Calling these will initialize all parent contracts so that the entire state is initialized in one transaction.
+    const expectedDirectCalls = remainingParents;
+
+    for (const contractInitializer of contractInitializers) {
+      yield* getInitializerCallExceptions(
+        contractInitializer,
+        expectedLinearized,
+        expectedDirectCalls,
+        parentNameToInitializersMap,
+        contractDef,
+        deref,
+        decodeSrc,
+      );
+    }
+  }
+}
+
+function getLinearizedParentContracts(contractDef: ContractDefinition, deref: ASTDereferencer) {
+  const parents = contractDef.linearizedBaseContracts.map(base => deref('ContractDefinition', base));
+  parents.reverse(); // use most derived first
+  parents.pop(); // remove self
+  return parents;
+}
+
+/**
+ * Gets a map of parent contract names to their possible initializers.
+ * If a parent contract has no initializers, it is not included in the map.
+ */
+function getParentNameToInitializersMap(linearizedParentContracts: ContractDefinition[]) {
+  const map = new Map();
+  for (const parent of linearizedParentContracts) {
+    const initializers = getPossibleInitializers(parent, true);
+    if (initializers.length > 0) {
+      map.set(parent.name, initializers);
+    }
+  }
+  return map;
+}
+
+/**
+ * Returns true if this contract must have its own initializer to call parent initializers.
+ *
+ * If there are multiple parents with initializers, regardless of whether they are internal or public,
+ * this contract must have its own initializer to call them so that the state is initialized in one transaction.
+ *
+ * Otherwise, if there is only one parent with initializers, they only need to be called if they are internal, since public initializers can be called directly.
+ */
+
+function checkNeedsInitialization(
+  remainingParents: string[],
+  parentNameToInitializersMap: Map<string, FunctionDefinition[]>,
+) {
+  if (remainingParents.length > 1) {
+    return true;
+  }
+  const [parent] = remainingParents;
+  const parentInitializers = parentNameToInitializersMap.get(parent)!;
+  return parentInitializers.every(init => init.visibility === 'internal');
+}
+
+/**
+ * Returns parent contract names that are not initialized by other parent contracts,
+ * keeping the same order as they appear in the original linearization.
+ */
+function getParentsNotInitializedByOtherParents(
+  parentNameToInitializersMap: Map<string, FunctionDefinition[]>,
+): string[] {
+  const remainingParents = [...parentNameToInitializersMap.keys()];
+
+  for (const parent of remainingParents) {
+    const parentInitializers = parentNameToInitializersMap.get(parent)!;
+    for (const initializer of parentInitializers) {
+      const expressionStatements =
+        initializer.body?.statements?.filter(stmt => stmt.nodeType === 'ExpressionStatement') ?? [];
+      for (const stmt of expressionStatements) {
+        const fnCall = stmt.expression;
+        if (
+          fnCall.nodeType === 'FunctionCall' &&
+          (fnCall.expression.nodeType === 'Identifier' || fnCall.expression.nodeType === 'MemberAccess')
+        ) {
+          const referencedFn = fnCall.expression.referencedDeclaration;
+          if (referencedFn && referencedFn > 0) {
+            const earlierParents = remainingParents.slice(0, remainingParents.indexOf(parent));
+            const callsEarlierParentInitializer = earlierParents.find(base =>
+              parentNameToInitializersMap.get(base)!.some(init => init.id === referencedFn),
+            );
+            if (callsEarlierParentInitializer) {
+              remainingParents.splice(remainingParents.indexOf(callsEarlierParentInitializer), 1);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return remainingParents;
+}
+
+/**
+ * Reports exceptions for missing initializer calls, duplicate initializer calls, and incorrect initializer order.
+ *
+ * @param contractInitializer An initializer function for the current contract
+ * @param expectedLinearized Linearized list of parent contracts that have initializers
+ * @param expectedDirectCalls The parent contracts that need to be directly initialized by this contract
+ * @param parentNameToInitializersMap Map of parent contract names to their possible initializers
+ * @param initializersCalledByParents List of parent initializers that have already been called by other parents
+ * @param contractDef The current contract
+ * @param deref AST dereferencer
+ * @param decodeSrc Source decoder
+ */
+function* getInitializerCallExceptions(
+  contractInitializer: FunctionDefinition,
+  expectedLinearized: string[],
+  expectedDirectCalls: string[],
+  parentNameToInitializersMap: Map<string, FunctionDefinition[]>,
+  contractDef: ContractDefinition,
+  deref: ASTDereferencer,
+  decodeSrc: SrcDecoder,
+): Generator<ValidationExceptionInitializer> {
+  const foundParents: string[] = [];
+  const remainingLinearized: string[] = [...expectedLinearized];
+  const remainingDirectCalls: string[] = [...expectedDirectCalls];
+  const calledInitializerIds: number[] = [];
+
+  const expressionStatements =
+    contractInitializer.body?.statements?.filter(stmt => stmt.nodeType === 'ExpressionStatement') ?? [];
+  for (const stmt of expressionStatements) {
+    const fnCall = stmt.expression;
+    if (
+      fnCall.nodeType === 'FunctionCall' &&
+      (fnCall.expression.nodeType === 'Identifier' || fnCall.expression.nodeType === 'MemberAccess')
+    ) {
+      let recursiveFunctionIds: number[] = [];
+      const referencedFn = fnCall.expression.referencedDeclaration;
+      if (referencedFn && referencedFn > 0) {
+        recursiveFunctionIds = getRecursiveFunctionIds(referencedFn, deref);
+      }
+
+      // For each recursively called function, if it is a parent initializer, then:
+      // - Check if it was already called (duplicate call)
+      // - Otherwise, check if the parent initializer is called in linearized order
+      for (const calledFn of recursiveFunctionIds) {
+        for (const parent of parentNameToInitializersMap.keys()) {
+          const parentInitializers = parentNameToInitializersMap.get(parent)!;
+          const callsParentInitializer = parentInitializers.find(init => init.id === calledFn);
+
+          if (calledFn && callsParentInitializer) {
+            const duplicate = calledInitializerIds.includes(calledFn);
+            if (
+              duplicate &&
+              !skipCheck('duplicate-initializer-call', contractDef) &&
+              !skipCheck('duplicate-initializer-call', contractInitializer) &&
+              !skipCheck('duplicate-initializer-call', stmt)
+            ) {
+              yield {
+                kind: 'duplicate-initializer-call',
+                src: decodeSrc(fnCall),
+                parentInitializer: callsParentInitializer.name,
+                parentContract: parent,
+              };
+            }
+            calledInitializerIds.push(calledFn);
+
+            // Omit multiple initializer calls of the same parent via different functions e.g. `__X_init` which calls `__X_init_unchained`
+            if (!foundParents.includes(parent)) {
+              foundParents.push(parent);
+
+              const indexLinearized = remainingLinearized.indexOf(parent);
+              if (
+                // Omit duplicate calls to avoid treating them as out of order. Duplicates are either reported above or they were skipped.
+                !duplicate &&
+                // If the parent is not the next expected linearized parent, report it as out of order
+                indexLinearized !== 0 &&
+                !skipCheck('incorrect-initializer-order', contractDef) &&
+                !skipCheck('incorrect-initializer-order', contractInitializer)
+              ) {
+                yield {
+                  kind: 'incorrect-initializer-order',
+                  src: decodeSrc(fnCall),
+                  expectedLinearization: expectedDirectCalls,
+                  foundOrder: foundParents,
+                };
+              }
+              if (indexLinearized !== -1) {
+                remainingLinearized.splice(indexLinearized, 1);
+              }
+
+              const indexDirect = remainingDirectCalls.indexOf(parent);
+              if (indexDirect !== -1) {
+                remainingDirectCalls.splice(indexDirect, 1);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Report any remaining parents that were not directly initialized
+  if (
+    remainingDirectCalls.length > 0 &&
+    !skipCheck('missing-initializer-call', contractDef) &&
+    !skipCheck('missing-initializer-call', contractInitializer)
+  ) {
+    yield {
+      kind: 'missing-initializer-call',
+      src: decodeSrc(contractInitializer),
+      parentContracts: remainingDirectCalls,
+    };
+  }
+}
+
+/**
+ * Gets the IDs of all functions that are recursively called by the given function, including the given function itself at the end of the list.
+ *
+ * @param referencedFn The ID of the function to start from
+ * @param deref AST dereferencer
+ * @param visited Set of function IDs that have already been visited
+ * @returns The IDs of all functions that are recursively called by the given function, including the given function itself at the end of the list.
+ */
+function getRecursiveFunctionIds(referencedFn: number, deref: ASTDereferencer, visited?: Set<number>): number[] {
+  const result: number[] = [];
+
+  if (visited === undefined) {
+    visited = new Set();
+  }
+  if (visited.has(referencedFn)) {
+    return result;
+  } else {
+    visited.add(referencedFn);
+  }
+
+  const fn = deref('FunctionDefinition', referencedFn);
+  const expressionStatements = fn.body?.statements?.filter(stmt => stmt.nodeType === 'ExpressionStatement') ?? [];
+  for (const stmt of expressionStatements) {
+    const fnCall = stmt.expression;
+    if (
+      fnCall.nodeType === 'FunctionCall' &&
+      (fnCall.expression.nodeType === 'Identifier' || fnCall.expression.nodeType === 'MemberAccess')
+    ) {
+      const referencedId = fnCall.expression.referencedDeclaration;
+      if (referencedId && referencedId > 0) {
+        result.push(...getRecursiveFunctionIds(referencedId, deref, visited));
+      }
+    }
+  }
+  result.push(referencedFn);
+
+  return result;
+}
+
+/**
+ * Get all functions that could be initializers. Does not include private functions.
+ * For parent contracts, only internal and public functions which contain statements are included.
+ */
+function getPossibleInitializers(contractDef: ContractDefinition, isParentContract: boolean) {
+  const fns = [...findAll('FunctionDefinition', contractDef)];
+  return fns.filter(
+    fnDef =>
+      (fnDef.modifiers.some(modifier => ['initializer', 'onlyInitializing'].includes(modifier.modifierName.name)) ||
+        ['initialize', 'initializer'].includes(fnDef.name)) &&
+      // Skip virtual functions without a body, since that indicates an abstract function and is not itself an initializer
+      !(fnDef.virtual && !fnDef.body) &&
+      // Ignore private functions, since they cannot be called outside the contract
+      fnDef.visibility !== 'private' &&
+      // For parent contracts, only internal and public functions which contain statements need to be called
+      (isParentContract
+        ? fnDef.body?.statements?.length && (fnDef.visibility === 'internal' || fnDef.visibility === 'public')
+        : true),
+  );
+}

package/src/validate/run.ts

@@ -24,6 +24,7 @@ import { getStorageLocationAnnotation, isNamespaceSupported } from '../storage/n
 import { UpgradesError } from '../error';
 import { assertUnreachable } from '../utils/assert';
 import { logWarning } from '../utils/log';
+import { getInitializerExceptions } from './run/initializer';
 
 export type ValidationRunData = Record<string, ContractValidation>;
 
@@ -50,13 +51,20 @@ export const errorKinds = [
   'selfdestruct',
   'missing-public-upgradeto',
   'internal-function-storage',
+  'missing-initializer',
+  'missing-initializer-call',
+  'duplicate-initializer-call',
+  'incorrect-initializer-order',
 ] as const;
 
+export const convertToWarnings: (typeof errorKinds)[number][] = ['incorrect-initializer-order'] as const;
+
 export type ValidationError =
   | ValidationErrorConstructor
   | ValidationErrorOpcode
   | ValidationErrorWithName
-  | ValidationErrorUpgradeability;
+  | ValidationErrorUpgradeability
+  | ValidationExceptionInitializer;
 
 interface ValidationErrorBase {
   src: string;
@@ -74,6 +82,33 @@ interface ValidationErrorWithName extends ValidationErrorBase {
     | 'internal-function-storage';
 }
 
+interface ValidationErrorMissingInitializer extends ValidationErrorBase {
+  kind: 'missing-initializer';
+}
+
+interface ValidationErrorMissingInitializerCall extends ValidationErrorBase {
+  kind: 'missing-initializer-call';
+  parentContracts: string[];
+}
+
+interface ValidationErrorDuplicateInitializerCall extends ValidationErrorBase {
+  kind: 'duplicate-initializer-call';
+  parentInitializer: string;
+  parentContract: string;
+}
+
+interface ValidationWarningIncorrectInitializerOrder extends ValidationErrorBase {
+  kind: 'incorrect-initializer-order';
+  expectedLinearization: string[];
+  foundOrder: string[];
+}
+
+export type ValidationExceptionInitializer =
+  | ValidationErrorMissingInitializer
+  | ValidationErrorMissingInitializerCall
+  | ValidationErrorDuplicateInitializerCall
+  | ValidationWarningIncorrectInitializerOrder;
+
 interface ValidationErrorConstructor extends ValidationErrorBase {
   kind: 'constructor';
   contract: string;
@@ -125,7 +160,7 @@ function skipCheckReachable(error: string, node: Node): boolean {
   return getAllowed(node, true).includes(error);
 }
 
-function skipCheck(error: string, node: Node): boolean {
+export function skipCheck(error: ValidationError['kind'], node: Node): boolean {
   // skip both allow and allow-reachable errors in the lexical scope
   return getAllowed(node, false).includes(error) || getAllowed(node, true).includes(error);
 }
@@ -209,6 +244,7 @@ export function validate(
           // https://github.com/OpenZeppelin/openzeppelin-upgrades/issues/52
           ...getLinkingErrors(contractDef, bytecode),
           ...getInternalFunctionStorageErrors(contractDef, deref, decodeSrc),
+          ...getInitializerExceptions(contractDef, deref, decodeSrc),
         ];
 
         validation[key].layout = extractStorageLayout(

package/src/validate-initializers.test.ts

@@ -0,0 +1,224 @@
+import _test, { TestFn } from 'ava';
+import { artifacts } from 'hardhat';
+
+import {
+  validate,
+  getContractVersion,
+  assertUpgradeSafe,
+  ValidationOptions,
+  RunValidation,
+  ValidationErrors,
+} from './validate';
+import { solcInputOutputDecoder } from './src-decoder';
+
+interface Context {
+  validation: RunValidation;
+}
+
+const test = _test as TestFn<Context>;
+
+test.before(async t => {
+  const contracts = ['contracts/test/ValidationsInitializer.sol:Parent_NoInitializer'];
+
+  t.context.validation = {} as RunValidation;
+  for (const contract of contracts) {
+    const buildInfo = await artifacts.getBuildInfo(contract);
+    if (buildInfo === undefined) {
+      throw new Error(`Build info not found for contract ${contract}`);
+    }
+    const solcOutput = buildInfo.output;
+    const solcInput = buildInfo.input;
+    const decodeSrc = solcInputOutputDecoder(solcInput, solcOutput);
+    Object.assign(t.context.validation, validate(solcOutput, decodeSrc));
+  }
+});
+
+function testAccepts(name: string, kind: ValidationOptions['kind']) {
+  testOverride(name, kind, {}, undefined);
+}
+
+interface ExpectedErrors {
+  contains: string[];
+  count: number;
+}
+
+function testRejects(name: string, kind: ValidationOptions['kind'], expectedErrors?: ExpectedErrors) {
+  testOverride(name, kind, {}, expectedErrors);
+}
+
+function testOverride(
+  name: string,
+  kind: ValidationOptions['kind'],
+  opts: ValidationOptions,
+  expectedErrors?: ExpectedErrors,
+) {
+  const expectValid = expectedErrors === undefined;
+
+  const optKeys = Object.keys(opts);
+  const describeOpts = optKeys.length > 0 ? '(' + optKeys.join(', ') + ')' : '';
+  const testName = [expectValid ? 'accepts' : 'rejects', kind, name, describeOpts].join(' ');
+  test(testName, t => {
+    const version = getContractVersion(t.context.validation, name);
+    const assertUpgSafe = () => assertUpgradeSafe([t.context.validation], version, { kind, ...opts });
+    if (expectValid) {
+      t.notThrows(assertUpgSafe);
+    } else {
+      const error = t.throws(assertUpgSafe) as ValidationErrors;
+      t.true(
+        error.errors.length === expectedErrors.count,
+        `Expected ${expectedErrors.count} errors, got ${error.errors.length}:\n${error.message}`,
+      );
+      t.true(
+        expectedErrors?.contains.every(c => error.message.includes(c)),
+        error.message,
+      );
+    }
+  });
+}
+
+testAccepts('Child_Of_NoInitializer_Ok', 'transparent');
+
+testAccepts('Child_Of_InitializerModifier_Ok', 'transparent');
+testRejects('Child_Of_InitializerModifier_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `Parent_InitializerModifier`'],
+  count: 1,
+});
+testAccepts('Child_Of_InitializerModifier_UsesSuper_Ok', 'transparent');
+
+testAccepts('Child_Of_OnlyInitializingModifier_Ok', 'transparent');
+testRejects('Child_Of_OnlyInitializingModifier_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `Parent__OnlyInitializingModifier`'],
+  count: 1,
+});
+
+testRejects('MissingInitializer_Bad', 'transparent', {
+  contains: ['Missing initializer'],
+  count: 1,
+});
+testAccepts('MissingInitializer_UnsafeAllow_Contract', 'transparent');
+testOverride('MissingInitializer_Bad', 'transparent', { unsafeAllow: ['missing-initializer'] });
+
+testAccepts('InitializationOrder_Ok', 'transparent');
+testAccepts('InitializationOrder_Ok_2', 'transparent');
+
+testAccepts('InitializationOrder_WrongOrder_Bad', 'transparent'); // warn 'Expected initializers to be called for parent contracts in the following order: A, B, C'
+testAccepts('InitializationOrder_WrongOrder_UnsafeAllow_Contract', 'transparent');
+testAccepts('InitializationOrder_WrongOrder_UnsafeAllow_Function', 'transparent');
+testOverride('InitializationOrder_WrongOrder_Bad', 'transparent', { unsafeAllow: ['incorrect-initializer-order'] }); // skips the warning
+
+testRejects('InitializationOrder_MissingCall_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `C`'],
+  count: 1,
+});
+testAccepts('InitializationOrder_MissingCall_UnsafeAllow_Contract', 'transparent');
+testAccepts('InitializationOrder_MissingCall_UnsafeAllow_Function', 'transparent');
+testOverride('InitializationOrder_MissingCall_Bad', 'transparent', { unsafeAllow: ['missing-initializer-call'] });
+
+testRejects('InitializationOrder_Duplicate_Bad', 'transparent', {
+  contains: ['Duplicate calls found to initializer `__B_init` for contract `B`'],
+  count: 1,
+});
+testAccepts('InitializationOrder_Duplicate_UnsafeAllow_Contract', 'transparent');
+testAccepts('InitializationOrder_Duplicate_UnsafeAllow_Function', 'transparent');
+testAccepts('InitializationOrder_Duplicate_UnsafeAllow_Call', 'transparent');
+testOverride('InitializationOrder_Duplicate_Bad', 'transparent', { unsafeAllow: ['duplicate-initializer-call'] });
+testAccepts('InitializationOrder_UnsafeAllowDuplicate_But_WrongOrder', 'transparent'); // warn 'Expected initializers to be called for parent contracts in the following order: A, B, C'
+
+testAccepts('WithRequire_Ok', 'transparent');
+testRejects('WithRequire_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `Parent__OnlyInitializingModifier`'],
+  count: 1,
+});
+
+testAccepts('Child_Of_Private_Ok', 'transparent');
+testAccepts('Child_Of_Public_Ok', 'transparent');
+testRejects('Child_Of_Public_MissingCall_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `Parent_Public`'],
+  count: 1,
+});
+testAccepts('Child_Of_External_Ok', 'transparent');
+testRejects('Child_Of_Internal_Bad', 'transparent', {
+  contains: ['Missing initializer'],
+  count: 1,
+});
+testRejects('Child_Of_Internal_Has_Private_Bad', 'transparent', {
+  contains: ['Missing initializer'],
+  count: 1,
+});
+testAccepts('Child_Of_Internal_Has_Public_Ok', 'transparent');
+testAccepts('Child_Of_Internal_Has_Internal_Ok', 'transparent');
+testAccepts('Child_Of_Internal_Has_External_Ok', 'transparent');
+testAccepts('Child_Of_PrivatePublicExternal_Ok', 'transparent');
+testRejects('Child_Of_AllVisibilities_Bad', 'transparent', {
+  contains: ['Missing initializer'],
+  count: 1,
+});
+testRejects('Child_Of_AllVisibilities_EmptyInitializer_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `Parent_Public, Parent_Internal`'],
+  count: 1,
+});
+
+testRejects('Child_Of_MultiplePublic_MissingInitializer_Bad', 'transparent', {
+  contains: ['Missing initializer'],
+  count: 1,
+});
+testRejects('Child_Of_MultiplePublic_MissingCall_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `Parent_Public_2`'],
+  count: 1,
+});
+testAccepts('Child_Of_MultiplePublic_Ok', 'transparent');
+
+testAccepts('TransitiveParent_Ok', 'transparent');
+testRejects('TransitiveParent_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `TransitiveGrandparent2`'],
+  count: 1,
+});
+testRejects('TransitiveChild_Bad_Parent', 'transparent', {
+  contains: [
+    'Missing initializer calls for one or more parent contracts: `TransitiveGrandparent2`', // occurs twice: missing initializer for child, missing initializer for parent
+  ],
+  count: 2,
+}); // warn 'Expected initializers to be called for parent contracts in the following order: TransitiveGrandparent2, TransitiveParent_Bad'
+testRejects('TransitiveChild_Bad_Order', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `TransitiveGrandparent2`'],
+  count: 1,
+}); // warn 'Expected initializers to be called for parent contracts in the following order: TransitiveGrandparent2, TransitiveParent_Bad'
+testRejects('TransitiveChild_Good_Order_Bad_Parent', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `TransitiveGrandparent2`'],
+  count: 1,
+});
+testRejects('TransitiveDuplicate_Bad', 'transparent', {
+  contains: [
+    'Duplicate calls found to initializer `__TransitiveGrandparent1_init` for contract `TransitiveGrandparent1`',
+  ],
+  count: 1,
+});
+
+testAccepts('Ownable_Ok', 'transparent');
+testAccepts('Ownable2Step_Ok', 'transparent');
+testRejects('Ownable2Step_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `OwnableUpgradeable`'],
+  count: 1,
+});
+
+testRejects('SkipsParent_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `Parent`'],
+  count: 1,
+});
+testRejects('DuplicateInHelpers_Bad', 'transparent', {
+  contains: ['Duplicate calls found to initializer `__Grandparent_init` for contract `Grandparent`'],
+  count: 1,
+});
+testRejects('Recursive_Bad', 'transparent', {
+  contains: ['Missing initializer calls for one or more parent contracts: `Parent`'],
+  count: 1,
+});
+testAccepts('Recursive_Ok', 'transparent');
+
+testAccepts('ERC20_Ok', 'uups');
+testRejects('ERC20_Bad', 'uups', {
+  contains: [
+    'Missing initializer calls for one or more parent contracts: `ERC20Upgradeable, ERC20PausableUpgradeable, OwnableUpgradeable, ERC20PermitUpgradeable`',
+  ],
+  count: 1,
+});