@openzeppelin/wizard 0.3.0 → 0.4.1

package/src/governor.ts

@@ -11,7 +11,7 @@ import { durationToBlocks } from "./utils/duration";
 
 export const defaults: Required<GovernorOptions> = {
   name: 'MyGovernor',
-  delay: '1 block',
+  delay: '1 day',
   period: '1 week',
 
   votes: 'erc20votes',
@@ -22,7 +22,7 @@ export const defaults: Required<GovernorOptions> = {
   quorumMode: 'percent',
   quorumPercent: 4,
   quorumAbsolute: '',
-  bravo: false,
+  storage: false,
   settings: true,
   
   access: commonDefaults.access,
@@ -30,7 +30,7 @@ export const defaults: Required<GovernorOptions> = {
   info: commonDefaults.info
 } as const;
 
-export const votesOptions = ['erc20votes', 'erc721votes', 'comp'] as const;
+export const votesOptions = ['erc20votes', 'erc721votes'] as const;
 export type VotesOptions = typeof votesOptions[number];
 
 export const timelockOptions = [false, 'openzeppelin', 'compound'] as const;
@@ -52,7 +52,7 @@ export interface GovernorOptions extends CommonOptions {
   quorumAbsolute?: string;
   votes?: VotesOptions;
   timelock?: TimelockOptions;
-  bravo?: boolean;
+  storage?: boolean;
   settings?: boolean;
 }
 
@@ -70,7 +70,7 @@ function withDefaults(opts: GovernorOptions): Required<GovernorOptions> {
     quorumAbsolute: opts.quorumAbsolute ?? defaults.quorumAbsolute,
     proposalThreshold: opts.proposalThreshold || defaults.proposalThreshold,
     settings: opts.settings ?? defaults.settings,
-    bravo: opts.bravo ?? defaults.bravo,
+    storage: opts.storage ?? defaults.storage,
     quorumMode: opts.quorumMode ?? defaults.quorumMode,
     votes: opts.votes ?? defaults.votes,
     timelock: opts.timelock ?? defaults.timelock
@@ -86,9 +86,9 @@ export function buildGovernor(opts: GovernorOptions): Contract {
 
   addBase(c, allOpts);
   addSettings(c, allOpts);
-  addCounting(c, allOpts);
-  addBravo(c, allOpts);
-  addVotes(c, allOpts);
+  addCounting(c);
+  addStorage(c, allOpts);
+  addVotes(c);
   addQuorum(c, allOpts);
   addTimelock(c, allOpts);
 
@@ -100,42 +100,43 @@ export function buildGovernor(opts: GovernorOptions): Contract {
 }
 
 function addBase(c: ContractBuilder, { name }: GovernorOptions) {
-  c.addParent(
-    {
-      name: 'Governor',
-      path: '@openzeppelin/contracts/governance/Governor.sol',
-    },
-    [name],
-  );
-  c.addOverride('IGovernor', functions.votingDelay);
-  c.addOverride('IGovernor', functions.votingPeriod);
-  c.addOverride('IGovernor', functions.quorum);
-  c.addOverride('Governor', functions.state);
-  c.addOverride('Governor', functions.propose);
-  c.addOverride('Governor', functions.proposalThreshold);
-  c.addOverride('Governor', functions._execute);
-  c.addOverride('Governor', functions._cancel);
-  c.addOverride('Governor', functions._executor);
-  c.addOverride('Governor', supportsInterface);
-  c.addOverride('Governor', functions.cancel);
+  const Governor = {
+    name: 'Governor',
+    path: '@openzeppelin/contracts/governance/Governor.sol',
+  };
+  c.addParent(Governor, [name]);
+  c.addOverride(Governor, functions.votingDelay);
+  c.addOverride(Governor, functions.votingPeriod);
+  c.addOverride(Governor, functions.quorum);
+  c.addOverride(Governor, functions.state);
+  c.addOverride(Governor, functions.propose);
+  c.addOverride(Governor, functions.proposalNeedsQueuing);
+  c.addOverride(Governor, functions.proposalThreshold);
+  c.addOverride(Governor, functions._propose);
+  c.addOverride(Governor, functions._queueOperations);
+  c.addOverride(Governor, functions._executeOperations);
+  c.addOverride(Governor, functions._cancel);
+  c.addOverride(Governor, functions._executor);
+  c.addOverride(Governor, supportsInterface);
 }
 
 function addSettings(c: ContractBuilder, allOpts: Required<GovernorOptions>) {
   if (allOpts.settings) {
+    const GovernorSettings = {
+      name: 'GovernorSettings',
+      path: '@openzeppelin/contracts/governance/extensions/GovernorSettings.sol',
+    };
     c.addParent(
-      {
-        name: 'GovernorSettings',
-        path: '@openzeppelin/contracts/governance/extensions/GovernorSettings.sol',
-      },
+      GovernorSettings,
       [
         { value: getVotingDelay(allOpts), note: allOpts.delay },
         { value: getVotingPeriod(allOpts), note: allOpts.period },
         { lit: getProposalThreshold(allOpts) },
       ],
     );
-    c.addOverride('GovernorSettings', functions.votingDelay, 'view');
-    c.addOverride('GovernorSettings', functions.votingPeriod, 'view');
-    c.addOverride('GovernorSettings', functions.proposalThreshold, 'view');
+    c.addOverride(GovernorSettings, functions.votingDelay, 'view');
+    c.addOverride(GovernorSettings, functions.votingPeriod, 'view');
+    c.addOverride(GovernorSettings, functions.proposalThreshold, 'view');
   } else {
     setVotingParameters(c, allOpts);
     setProposalThreshold(c, allOpts);
@@ -209,42 +210,27 @@ function setProposalThreshold(c: ContractBuilder, opts: Required<GovernorOptions
   }
 }
 
-function addCounting(c: ContractBuilder, { bravo }: GovernorOptions) {
-  if (!bravo) {
-    c.addParent({
-      name: 'GovernorCountingSimple',
-      path: '@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol',
-    });
-  }
+function addCounting(c: ContractBuilder) {
+  c.addParent({
+    name: 'GovernorCountingSimple',
+    path: '@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol',
+  });
 }
 
-const votesModules = {
-  erc20votes: {
-    tokenType: 'IVotes',
-    parentName: 'GovernorVotes',
-  },
-  erc721votes: {
-    tokenType: 'IVotes',
-    parentName: 'GovernorVotes',
-  },
-  comp: {
-    tokenType: 'ERC20VotesComp',
-    parentName: 'GovernorVotesComp',
-  },
-} as const;
-
-function addVotes(c: ContractBuilder, { votes }: Required<GovernorOptions>) {
+function addVotes(c: ContractBuilder) {
   const tokenArg = '_token';
-  const { tokenType, parentName } = votesModules[votes];
 
   c.addConstructorArgument({
-    type: tokenType,
+    type: {
+      name: 'IVotes',
+      transpiled: false,
+    },
     name: tokenArg,
   });
 
   c.addParent({
-    name: parentName,
-    path: `@openzeppelin/contracts/governance/extensions/${parentName}.sol`,
+    name: 'GovernorVotes',
+    path: `@openzeppelin/contracts/governance/extensions/GovernorVotes.sol`,
   }, [{ lit: tokenArg }]);
 }
 
@@ -252,12 +238,6 @@ export const numberPattern = /^(?!$)(\d*)(?:\.(\d+))?(?:e(\d+))?$/;
 
 function addQuorum(c: ContractBuilder, opts: Required<GovernorOptions>) {
   if (opts.quorumMode === 'percent') {
-    if (opts.votes !== 'erc20votes' && opts.votes !== 'erc721votes') {
-      throw new OptionsError({
-        quorumPercent: 'Percent-based quorum is only available for ERC20Votes or ERC721Votes',
-      });
-    }
-
     if (opts.quorumPercent > 100) {
       throw new OptionsError({
         quorumPercent: 'Invalid percentage',
@@ -266,18 +246,20 @@ function addQuorum(c: ContractBuilder, opts: Required<GovernorOptions>) {
 
     let { quorumFractionNumerator, quorumFractionDenominator } = getQuorumFractionComponents(opts.quorumPercent);
 
+    const GovernorVotesQuorumFraction = {
+      name: 'GovernorVotesQuorumFraction',
+      path: '@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol',
+    };
+
     if (quorumFractionDenominator !== undefined) {
-      c.addOverride('GovernorVotesQuorumFraction', functions.quorumDenominator);
+      c.addOverride(GovernorVotesQuorumFraction, functions.quorumDenominator);
       c.setFunctionBody([
         `return ${quorumFractionDenominator};`
       ], functions.quorumDenominator, 'pure');
     }
 
-    c.addParent({
-      name: 'GovernorVotesQuorumFraction',
-      path: '@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol',
-    }, [quorumFractionNumerator]);
-    c.addOverride('GovernorVotesQuorumFraction', functions.quorum);
+    c.addParent(GovernorVotesQuorumFraction, [quorumFractionNumerator]);
+    c.addOverride(GovernorVotesQuorumFraction, functions.quorum);
   }
 
   else if (opts.quorumMode === 'absolute') {
@@ -299,12 +281,23 @@ function addQuorum(c: ContractBuilder, opts: Required<GovernorOptions>) {
 
 const timelockModules = {
   openzeppelin: {
-    timelockType: 'TimelockController',
-    parentName: 'GovernorTimelockControl',
+    timelockType: {
+      name: 'TimelockController',
+    },
+    timelockParent: {
+      name: 'GovernorTimelockControl',
+      path: `@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol`,
+    }
   },
   compound: {
-    timelockType: 'ICompoundTimelock',
-    parentName: 'GovernorTimelockCompound',
+    timelockType: {
+      name: 'ICompoundTimelock',
+      transpiled: false,
+    },
+    timelockParent: {
+      name: 'GovernorTimelockCompound',
+      path: `@openzeppelin/contracts/governance/extensions/GovernorTimelockCompound.sol`,
+    }
   },
 } as const;
 
@@ -334,42 +327,30 @@ function addTimelock(c: ContractBuilder, { timelock }: Required<GovernorOptions>
   }
 
   const timelockArg = '_timelock';
-  const { timelockType, parentName } = timelockModules[timelock];
+  const { timelockType, timelockParent } = timelockModules[timelock];
 
   c.addConstructorArgument({
     type: timelockType,
     name: timelockArg,
   });
 
-  c.addParent({
-    name: parentName,
-    path: `@openzeppelin/contracts/governance/extensions/${parentName}.sol`,
-  }, [{ lit: timelockArg }]);
-  c.addOverride('IGovernor', functions.propose);
-  c.addOverride(parentName, functions._execute);
-  c.addOverride(parentName, functions._cancel);
-  c.addOverride(parentName, functions._executor);
-  c.addOverride(parentName, functions.state);
-  c.addOverride(parentName, supportsInterface);
+  c.addParent(timelockParent, [{ lit: timelockArg }]);
+  c.addOverride(timelockParent, functions._queueOperations);
+  c.addOverride(timelockParent, functions._executeOperations);
+  c.addOverride(timelockParent, functions._cancel);
+  c.addOverride(timelockParent, functions._executor);
+  c.addOverride(timelockParent, functions.state);
+  c.addOverride(timelockParent, functions.proposalNeedsQueuing);
 }
 
-function addBravo(c: ContractBuilder, { bravo, timelock }: GovernorOptions) {
-  if (bravo) {
-    if (timelock === false) {
-      throw new OptionsError({
-        timelock: 'GovernorBravo compatibility requires a timelock',
-      });
-    }
-
-    c.addParent({
-      name: 'GovernorCompatibilityBravo',
-      path: '@openzeppelin/contracts/governance/compatibility/GovernorCompatibilityBravo.sol',
-    });
-    c.addOverride('IGovernor', functions.state);
-    c.addOverride('IGovernor', functions.cancel);
-    c.addOverride('GovernorCompatibilityBravo', functions.cancel);
-    c.addOverride('GovernorCompatibilityBravo', functions.propose);
-    c.addOverride('IERC165', supportsInterface);
+function addStorage(c: ContractBuilder, { storage }: GovernorOptions) {
+  if (storage) {
+    const GovernorStorage = {
+      name: 'GovernorStorage',
+      path: '@openzeppelin/contracts/governance/extensions/GovernorStorage.sol',
+    };
+    c.addParent(GovernorStorage);
+    c.addOverride(GovernorStorage, functions._propose);
   }
 }
 
@@ -392,6 +373,14 @@ const functions = defineFunctions({
     kind: 'public',
     mutability: 'pure',
   },
+  proposalNeedsQueuing: {
+    args: [
+      { name: 'proposalId', type: 'uint256' },
+    ],
+    returns: ['bool'],
+    kind: 'public',
+    mutability: 'view',
+  },
   quorum: {
     args: [
       { name: 'blockNumber', type: 'uint256' },
@@ -416,7 +405,18 @@ const functions = defineFunctions({
     returns: ['uint256'],
     kind: 'public',
   },
-  _execute: {
+  _propose: {
+    args: [
+      { name: 'targets', type: 'address[] memory' },
+      { name: 'values', type: 'uint256[] memory' },
+      { name: 'calldatas', type: 'bytes[] memory' },
+      { name: 'description', type: 'string memory' },
+      { name: 'proposer', type: 'address' },
+    ],
+    returns: ['uint256'],
+    kind: 'internal',
+  },
+  _queueOperations: {
     args: [
       { name: 'proposalId', type: 'uint256' },
       { name: 'targets', type: 'address[] memory' },
@@ -425,18 +425,19 @@ const functions = defineFunctions({
       { name: 'descriptionHash', type: 'bytes32' },
     ],
     kind: 'internal',
+    returns: ['uint48'],
   },
-  _cancel: {
+  _executeOperations: {
     args: [
+      { name: 'proposalId', type: 'uint256' },
       { name: 'targets', type: 'address[] memory' },
       { name: 'values', type: 'uint256[] memory' },
       { name: 'calldatas', type: 'bytes[] memory' },
       { name: 'descriptionHash', type: 'bytes32' },
     ],
-    returns: ['uint256'],
     kind: 'internal',
   },
-  cancel: {
+  _cancel: {
     args: [
       { name: 'targets', type: 'address[] memory' },
       { name: 'values', type: 'uint256[] memory' },
@@ -444,7 +445,7 @@ const functions = defineFunctions({
       { name: 'descriptionHash', type: 'bytes32' },
     ],
     returns: ['uint256'],
-    kind: 'public',
+    kind: 'internal',
   },
   state: {
     args: [

package/src/infer-transpiled.ts

@@ -0,0 +1,5 @@
+import type { ReferencedContract } from "./contract";
+
+export function inferTranspiled(c: ReferencedContract): boolean {
+  return c.transpiled ?? !/^I[A-Z]/.test(c.name);
+}

package/src/options.ts

@@ -1,6 +1,7 @@
 import path from 'path';
 
-import type { Contract } from './contract';
+import type { Contract, ReferencedContract, ParentContract } from './contract';
+import { inferTranspiled } from './infer-transpiled';
 
 const upgradeableName = (n: string) => {
   if (n === 'Initializable') {
@@ -10,36 +11,37 @@ const upgradeableName = (n: string) => {
   }
 }
 
-const upgradeableImport = (p: string) => {
-  const { dir, ext, name } = path.parse(p);
+const upgradeableImport = (p: ParentContract): ParentContract => {
+  const { dir, ext, name } = path.parse(p.path);
   // Use path.posix to get forward slashes
-  return path.posix.format({
-    ext,
-    dir: dir.replace(/^@openzeppelin\/contracts/, '@openzeppelin/contracts-upgradeable'),
-    name: upgradeableName(name),
-  });
+  return {
+    ...p,
+    path: path.posix.format({
+      ext,
+      dir: dir.replace(/^@openzeppelin\/contracts/, '@openzeppelin/contracts-upgradeable'),
+      name: upgradeableName(name),
+    }),
+  }
 };
 
 export interface Options {
-  transformImport?: (path: string) => string;
+  transformImport?: (parent: ParentContract) => ParentContract;
 }
 
 export interface Helpers extends Required<Options> {
   upgradeable: boolean;
-  transformName: (name: string) => string;
-  transformVariable: (code: string) => string;
+  transformName: (name: ReferencedContract) => string;
 }
 
 export function withHelpers(contract: Contract, opts: Options = {}): Helpers {
-  const upgradeable = contract.upgradeable;
-  const transformName = (n: string) => upgradeable ? upgradeableName(n) : n;
+  const contractUpgradeable = contract.upgradeable;
+  const transformName = (n: ReferencedContract) => contractUpgradeable && inferTranspiled(n) ? upgradeableName(n.name) : n.name;
   return {
-    upgradeable,
+    upgradeable: contractUpgradeable,
     transformName,
     transformImport: p1 => {
-      const p2 = upgradeable ? upgradeableImport(p1) : p1;
+      const p2 = contractUpgradeable && inferTranspiled(p1) ? upgradeableImport(p1) : p1;
       return opts.transformImport?.(p2) ?? p2;
     },
-    transformVariable: v => v.replace(/[A-Z]\w*(?=\.|$)/, transformName),
   };
 }

package/src/print-versioned.ts

@@ -4,8 +4,12 @@ import { printContract } from "./print";
 
 export function printContractVersioned(contract: Contract): string {
   return printContract(contract, {
-    transformImport: p =>
-      p.replace(/^@openzeppelin\/contracts(-upgradeable)?/, `$&@${contracts.version}`),
+    transformImport: p => {
+      return {
+        ...p,
+        path: p.path.replace(/^@openzeppelin\/contracts(-upgradeable)?/, `$&@${contracts.version}`),
+      }
+    }
   });
 }
 

package/src/print.ts

@@ -6,6 +6,7 @@ import { Options, Helpers, withHelpers } from './options';
 import { formatLines, spaceBetween, Lines } from './utils/format-lines';
 import { mapValues } from './utils/map-values';
 import SOLIDITY_VERSION from './solidity-version.json';
+import { inferTranspiled } from './infer-transpiled';
 
 export function printContract(contract: Contract, opts?: Options): string {
   const helpers = withHelpers(contract, opts);
@@ -24,15 +25,14 @@ export function printContract(contract: Contract, opts?: Options): string {
         `pragma solidity ^${SOLIDITY_VERSION};`,
       ],
 
-      contract.imports.map(p => `import "${helpers.transformImport(p)}";`),
+      contract.imports.map(p => `import "${helpers.transformImport(p).path}";`),
 
       [
         ...printNatspecTags(contract.natspecTags),
         [`contract ${contract.name}`, ...printInheritance(contract, helpers), '{'].join(' '),
 
         spaceBetween(
-          printUsingFor(contract, helpers),
-          contract.variables.map(helpers.transformVariable),
+          contract.variables,
           printConstructor(contract, helpers),
           ...fns.code,
           ...fns.modifiers,
@@ -48,18 +48,12 @@ export function printContract(contract: Contract, opts?: Options): string {
 
 function printInheritance(contract: Contract, { transformName }: Helpers): [] | [string] {
   if (contract.parents.length > 0) {
-    return ['is ' + contract.parents.map(p => transformName(p.contract.name)).join(', ')];
+    return ['is ' + contract.parents.map(p => transformName(p.contract)).join(', ')];
   } else {
     return [];
   }
 }
 
-function printUsingFor(contract: Contract, { transformName }: Helpers): string[] {
-  return contract.using.map(
-    u => `using ${transformName(u.library.name)} for ${transformName(u.usingFor)};`,
-  );
-}
-
 function printConstructor(contract: Contract, helpers: Helpers): Lines[] {
   const hasParentParams = contract.parents.some(p => p.params.length > 0);
   const hasConstructorCode = contract.constructorCode.length > 0;
@@ -134,8 +128,9 @@ function sortedFunctions(contract: Contract): SortedFunctions {
 }
 
 function printParentConstructor({ contract, params }: Parent, helpers: Helpers): [] | [string] {
-  const fn = helpers.upgradeable ? `__${contract.name}_init` : contract.name;
-  if (helpers.upgradeable || params.length > 0) {
+  const useTranspiled = helpers.upgradeable && inferTranspiled(contract);
+  const fn = useTranspiled ? `__${contract.name}_init` : contract.name;
+  if (useTranspiled || params.length > 0) {
     return [
       fn + '(' + params.map(printValue).join(', ') + ')',
     ];
@@ -231,7 +226,16 @@ function printFunction2(kindedName: string, args: string[], modifiers: string[],
 }
 
 function printArgument(arg: FunctionArgument, { transformName }: Helpers): string {
-  const type = /^[A-Z]/.test(arg.type) ? transformName(arg.type) : arg.type;
+  let type: string;
+  if (typeof arg.type === 'string') {
+    if (/^[A-Z]/.test(arg.type)) {
+      `Type ${arg.type} is not a primitive type. Define it as a ContractReference`;
+    }
+    type = arg.type;
+  } else {
+    type = transformName(arg.type);
+  }
+
   return [type, arg.name].join(' ');
 }
 

package/src/scripts/prepare.ts

@@ -2,10 +2,8 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import hre from 'hardhat';
 import type { BuildInfo } from 'hardhat/types';
-import type { SourceUnit } from 'solidity-ast';
 import { findAll } from 'solidity-ast/utils';
 import { rimraf } from 'rimraf';
-import { promisify } from 'util';
 import { version } from "@openzeppelin/contracts/package.json";
 
 import type { OpenZeppelinContracts } from '../../openzeppelin-contracts';

package/src/set-access-control.ts

@@ -1,7 +1,7 @@
 import type { ContractBuilder, BaseFunction } from './contract';
 import { supportsInterface } from './common-functions';
 
-export const accessOptions = [false, 'ownable', 'roles'] as const;
+export const accessOptions = [false, 'ownable', 'roles', 'managed'] as const;
 
 export type Access = typeof accessOptions[number];
 
@@ -11,14 +11,32 @@ export type Access = typeof accessOptions[number];
 export function setAccessControl(c: ContractBuilder, access: Access) {
   switch (access) {
     case 'ownable': {
-      c.addParent(parents.Ownable);
+      if (c.addParent(parents.Ownable, [ {lit: 'initialOwner'} ])) {
+        c.addConstructorArgument({
+          type: 'address',
+          name: 'initialOwner'
+        });
+      }
       break;
     }
     case 'roles': {
       if (c.addParent(parents.AccessControl)) {
-        c.addConstructorCode('_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);');
+        c.addConstructorArgument({
+          type: 'address',
+          name: 'defaultAdmin'
+        });
+        c.addConstructorCode('_grantRole(DEFAULT_ADMIN_ROLE, defaultAdmin);');
+      }
+      c.addOverride(parents.AccessControl, supportsInterface);
+      break;
+    }
+    case 'managed': {
+      if (c.addParent(parents.AccessManaged, [ {lit: 'initialAuthority'} ])) {
+        c.addConstructorArgument({
+          type: 'address',
+          name: 'initialAuthority'
+        });
       }
-      c.addOverride(parents.AccessControl.name, supportsInterface);
       break;
     }
   }
@@ -27,7 +45,7 @@ export function setAccessControl(c: ContractBuilder, access: Access) {
 /**
  * Enables access control for the contract and restricts the given function with access control.
  */
-export function requireAccessControl(c: ContractBuilder, fn: BaseFunction, access: Access, role: string) {
+export function requireAccessControl(c: ContractBuilder, fn: BaseFunction, access: Access, roleIdPrefix: string, roleOwner: string | undefined) {
   if (access === false) {
     access = 'ownable';
   }
@@ -40,13 +58,19 @@ export function requireAccessControl(c: ContractBuilder, fn: BaseFunction, acces
       break;
     }
     case 'roles': {
-      const roleId = role + '_ROLE';
-      if (c.addVariable(`bytes32 public constant ${roleId} = keccak256("${roleId}");`)) {
-        c.addConstructorCode(`_grantRole(${roleId}, msg.sender);`);
+      const roleId = roleIdPrefix + '_ROLE';
+      const addedConstant = c.addVariable(`bytes32 public constant ${roleId} = keccak256("${roleId}");`);
+      if (roleOwner && addedConstant) {
+        c.addConstructorArgument({type: 'address', name: roleOwner});
+        c.addConstructorCode(`_grantRole(${roleId}, ${roleOwner});`);
       }
       c.addModifier(`onlyRole(${roleId})`, fn);
       break;
     }
+    case 'managed': {
+      c.addModifier('restricted', fn);
+      break;
+    }
   }
 }
 
@@ -59,4 +83,8 @@ const parents = {
     name: 'AccessControl',
     path: '@openzeppelin/contracts/access/AccessControl.sol',
   },
+  AccessManaged: {
+    name: 'AccessManaged',
+    path: '@openzeppelin/contracts/access/manager/AccessManaged.sol',
+  },
 };

package/src/set-upgradeable.ts

@@ -22,12 +22,13 @@ export function setUpgradeable(c: ContractBuilder, upgradeable: Upgradeable, acc
     case 'transparent': break;
 
     case 'uups': {
-      requireAccessControl(c, functions._authorizeUpgrade, access, 'UPGRADER');
-      c.addParent({
+      requireAccessControl(c, functions._authorizeUpgrade, access, 'UPGRADER', 'upgrader');
+      const UUPSUpgradeable = {
         name: 'UUPSUpgradeable',
         path: '@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol',
-      });
-      c.addOverride('UUPSUpgradeable', functions._authorizeUpgrade);
+      };
+      c.addParent(UUPSUpgradeable);
+      c.addOverride(UUPSUpgradeable, functions._authorizeUpgrade);
       c.setFunctionBody([], functions._authorizeUpgrade);
       break;
     }

package/src/solidity-version.json

@@ -1 +1 @@
-"0.8.9"
+"0.8.20"