@openzeppelin/wizard 0.7.1 → 0.8.0

package/src/generate/account.ts

@@ -1,5 +1,6 @@
 import type { AccountOptions } from '../account';
 import { infoOptions } from '../set-info';
+import { upgradeableOptions } from '../set-upgradeable';
 import { generateAlternatives } from './alternatives';
 
 const account = {
@@ -11,7 +12,7 @@ const account = {
   batchedExecution: [false, true] as const,
   ERC7579Modules: [false, 'AccountERC7579', 'AccountERC7579Hooked'] as const,
   access: [false] as const,
-  upgradeable: [false] as const,
+  upgradeable: upgradeableOptions,
   info: infoOptions,
 };
 

package/src/options.ts

@@ -3,15 +3,15 @@ import path from 'path';
 import type { Contract, ReferencedContract, ImportContract } from './contract';
 import { inferTranspiled } from './infer-transpiled';
 
-const upgradeableName = (n: string) => {
+export function upgradeableName(n: string) {
   if (n === 'Initializable') {
     return n;
   } else {
     return n.replace(/(Upgradeable)?(?=\.|$)/, 'Upgradeable');
   }
-};
+}
 
-const upgradeableImport = (p: ImportContract): ImportContract => {
+export function upgradeableImport(p: ImportContract): ImportContract {
   const { dir, ext, name } = path.parse(p.path);
   // Use path.posix to get forward slashes
   return {
@@ -23,7 +23,7 @@ const upgradeableImport = (p: ImportContract): ImportContract => {
       name: upgradeableName(name), // Solidity file name
     }),
   };
-};
+}
 
 export interface Options {
   transformImport?: (parent: ImportContract) => ImportContract;
@@ -32,16 +32,16 @@ export interface Options {
 export interface Helpers extends Required<Options> {
   upgradeable: boolean;
   transformName: (name: ReferencedContract) => string;
+  transformImport: (name: ImportContract) => ImportContract;
 }
 
 export function withHelpers(contract: Contract, opts: Options = {}): Helpers {
   const contractUpgradeable = contract.upgradeable;
-  const transformName = (n: ReferencedContract) =>
-    contractUpgradeable && inferTranspiled(n) ? upgradeableName(n.name) : n.name;
   return {
     upgradeable: contractUpgradeable,
-    transformName,
-    transformImport: p1 => {
+    transformName: (n: ReferencedContract) =>
+      contractUpgradeable && inferTranspiled(n) ? upgradeableName(n.name) : n.name,
+    transformImport: (p1: ImportContract) => {
       const p2 = contractUpgradeable && inferTranspiled(p1) ? upgradeableImport(p1) : p1;
       return opts.transformImport?.(p2) ?? p2;
     },

package/src/print.ts

@@ -82,21 +82,39 @@ function printConstructor(contract: Contract, helpers: Helpers): Lines[] {
   const hasConstructorCode = contract.constructorCode.length > 0;
   const parentsWithInitializers = contract.parents.filter(hasInitializer);
   if (hasParentParams || hasConstructorCode || (helpers.upgradeable && parentsWithInitializers.length > 0)) {
-    const parents = parentsWithInitializers.flatMap(p => printParentConstructor(p, helpers));
-    const modifiers = helpers.upgradeable ? ['public initializer'] : parents;
-    const args = contract.constructorArgs.map(a => printArgument(a, helpers));
-    const body = helpers.upgradeable
-      ? spaceBetween(
-          parents.map(p => p + ';'),
+    if (helpers.upgradeable) {
+      const upgradeableParents = parentsWithInitializers.filter(p => inferTranspiled(p.contract));
+      const nonUpgradeableParents = contract.parents.filter(p => !inferTranspiled(p.contract));
+      const constructor = printFunction2(
+        [
+          nonUpgradeableParents.length > 0
+            ? '/// @custom:oz-upgrades-unsafe-allow-reachable constructor'
+            : '/// @custom:oz-upgrades-unsafe-allow constructor',
+        ],
+        'constructor',
+        [],
+        nonUpgradeableParents.flatMap(p => printParentConstructor(p, helpers)),
+        ['_disableInitializers();'],
+      );
+      const initializer = printFunction2(
+        [],
+        'function initialize',
+        contract.constructorArgs.map(a => printArgument(a, helpers)),
+        ['public', 'initializer'],
+        spaceBetween(
+          upgradeableParents.flatMap(p => printParentConstructor(p, helpers)).map(p => p + ';'),
           contract.constructorCode,
-        )
-      : contract.constructorCode;
-    const head = helpers.upgradeable ? 'function initialize' : 'constructor';
-    const constructor = printFunction2([], head, args, modifiers, body);
-    if (!helpers.upgradeable) {
-      return constructor;
+        ),
+      );
+      return spaceBetween(constructor, upgradeableParents.length > 0 ? initializer : []);
     } else {
-      return spaceBetween(DISABLE_INITIALIZERS, constructor);
+      return printFunction2(
+        [],
+        'constructor',
+        contract.constructorArgs.map(a => printArgument(a, helpers)),
+        contract.parents.flatMap(p => printParentConstructor(p, helpers)),
+        contract.constructorCode,
+      );
     }
   } else if (!helpers.upgradeable) {
     return [];

package/src/set-upgradeable.ts

@@ -58,6 +58,12 @@ export function setUpgradeableGovernor(c: ContractBuilder, upgradeable: Upgradea
   });
 }
 
+export function setUpgradeableAccount(c: ContractBuilder, upgradeable: Upgradeable) {
+  setUpgradeableBase(c, upgradeable, () => {
+    c.addModifier('onlyEntryPointOrSelf', functions._authorizeUpgrade);
+  });
+}
+
 const functions = defineFunctions({
   _authorizeUpgrade: {
     args: [{ name: 'newImplementation', type: 'address' }],

package/src/signer.ts

@@ -1,112 +1,91 @@
 import type { ContractBuilder } from './contract';
+import { OptionsError } from './error';
+import type { Upgradeable } from './set-upgradeable';
 import { defineFunctions } from './utils/define-functions';
 
 export const SignerOptions = [false, 'ERC7702', 'ECDSA', 'P256', 'RSA', 'Multisig', 'MultisigWeighted'] as const;
 export type SignerOptions = (typeof SignerOptions)[number];
 
-export function addSigner(c: ContractBuilder, signer: SignerOptions): void {
+export function addSigner(c: ContractBuilder, signer: SignerOptions, upgradeable: Upgradeable): void {
   if (!signer) return;
 
-  c.addParent(signers[signer]);
-  c.addOverride(
-    { name: signer === 'MultisigWeighted' ? signers.Multisig.name : signers[signer].name },
-    signerFunctions._rawSignatureValidation,
-  );
-
-  // ERC-7702 doesn't require initialization
-  if (signer === 'ERC7702') return;
-
-  c.addParent({
-    name: 'Initializable',
-    path: '@openzeppelin/contracts/proxy/utils/Initializable.sol',
-  });
-
-  // Add locking constructor
-  c.addNatspecTag('@custom:oz-upgrades-unsafe-allow', 'constructor');
-  c.addConstructorCode(`_disableInitializers();`);
-
-  // Add initializer
-  const fn = signerFunctions[`initialize${signer}`];
-  c.addModifier('initializer', fn);
+  const signerName = signer === 'MultisigWeighted' ? signers.Multisig.name : signers[signer].name;
+  c.addOverride({ name: signerName }, signerFunctions._rawSignatureValidation);
 
   switch (signer) {
-    case 'Multisig':
-      c.addFunctionCode(`_addSigners(${fn.args[0]!.name});`, fn);
-      c.addFunctionCode(`_setThreshold(${fn.args[1]!.name});`, fn);
-      break;
-    case 'MultisigWeighted':
-      c.addFunctionCode(`_addSigners(${fn.args[0]!.name});`, fn);
-      c.addFunctionCode(`_setSignerWeights(${fn.args[0]!.name}, ${fn.args[1]!.name});`, fn);
-      c.addFunctionCode(`_setThreshold(${fn.args[2]!.name});`, fn);
+    case 'ERC7702':
+      c.addParent(signers[signer]);
+      if (upgradeable) {
+        throw new OptionsError({
+          erc7702: 'EOAs can upgrade by redelegating to a new account',
+          upgradeable: 'EOAs can upgrade by redelegating to a new account',
+        });
+      }
       break;
     case 'ECDSA':
     case 'P256':
     case 'RSA':
-      c.addFunctionCode(`_setSigner(${fn.args.map(({ name }) => name).join(', ')});`, fn);
+    case 'Multisig':
+    case 'MultisigWeighted': {
+      signerArgs[signer].forEach(arg => c.addConstructorArgument(arg));
+      c.addParent(
+        signers[signer],
+        signerArgs[signer].map(arg => ({ lit: arg.name })),
+      );
+      break;
+    }
   }
 }
 
 export const signers = {
   ERC7702: {
     name: 'SignerERC7702',
-    path: '@openzeppelin/community-contracts/utils/cryptography/SignerERC7702.sol',
+    path: '@openzeppelin/contracts/utils/cryptography/signers/SignerERC7702.sol',
   },
   ECDSA: {
     name: 'SignerECDSA',
-    path: '@openzeppelin/community-contracts/utils/cryptography/SignerECDSA.sol',
+    path: '@openzeppelin/contracts/utils/cryptography/signers/SignerECDSA.sol',
   },
   P256: {
     name: 'SignerP256',
-    path: '@openzeppelin/community-contracts/utils/cryptography/SignerP256.sol',
+    path: '@openzeppelin/contracts/utils/cryptography/signers/SignerP256.sol',
   },
   RSA: {
     name: 'SignerRSA',
-    path: '@openzeppelin/community-contracts/utils/cryptography/SignerRSA.sol',
+    path: '@openzeppelin/contracts/utils/cryptography/signers/SignerRSA.sol',
   },
   Multisig: {
     name: 'MultiSignerERC7913',
-    path: '@openzeppelin/community-contracts/utils/cryptography/MultiSignerERC7913.sol',
+    path: '@openzeppelin/contracts/utils/cryptography/signers/MultiSignerERC7913.sol',
   },
   MultisigWeighted: {
     name: 'MultiSignerERC7913Weighted',
-    path: '@openzeppelin/community-contracts/utils/cryptography/MultiSignerERC7913Weighted.sol',
+    path: '@openzeppelin/contracts/utils/cryptography/signers/MultiSignerERC7913Weighted.sol',
   },
 };
 
+export const signerArgs: Record<Exclude<SignerOptions, false | 'ERC7702'>, { name: string; type: string }[]> = {
+  ECDSA: [{ name: 'signer', type: 'address' }],
+  P256: [
+    { name: 'qx', type: 'bytes32' },
+    { name: 'qy', type: 'bytes32' },
+  ],
+  RSA: [
+    { name: 'e', type: 'bytes memory' },
+    { name: 'n', type: 'bytes memory' },
+  ],
+  Multisig: [
+    { name: 'signers', type: 'bytes[] memory' },
+    { name: 'threshold', type: 'uint64' },
+  ],
+  MultisigWeighted: [
+    { name: 'signers', type: 'bytes[] memory' },
+    { name: 'weights', type: 'uint64[] memory' },
+    { name: 'threshold', type: 'uint64' },
+  ],
+};
+
 export const signerFunctions = defineFunctions({
-  initializeECDSA: {
-    kind: 'public' as const,
-    args: [{ name: 'signer', type: 'address' }],
-  },
-  initializeP256: {
-    kind: 'public' as const,
-    args: [
-      { name: 'qx', type: 'bytes32' },
-      { name: 'qy', type: 'bytes32' },
-    ],
-  },
-  initializeRSA: {
-    kind: 'public' as const,
-    args: [
-      { name: 'e', type: 'bytes memory' },
-      { name: 'n', type: 'bytes memory' },
-    ],
-  },
-  initializeMultisig: {
-    kind: 'public' as const,
-    args: [
-      { name: 'signers', type: 'bytes[] memory' },
-      { name: 'threshold', type: 'uint256' },
-    ],
-  },
-  initializeMultisigWeighted: {
-    kind: 'public' as const,
-    args: [
-      { name: 'signers', type: 'bytes[] memory' },
-      { name: 'weights', type: 'uint256[] memory' },
-      { name: 'threshold', type: 'uint256' },
-    ],
-  },
   _rawSignatureValidation: {
     kind: 'internal' as const,
     args: [

package/src/zip-foundry.ts

@@ -6,22 +6,82 @@ import SOLIDITY_VERSION from './solidity-version.json';
 import contracts from '../openzeppelin-contracts';
 import type { Lines } from './utils/format-lines';
 import { formatLinesWithSpaces, spaceBetween } from './utils/format-lines';
+import type { Upgradeable } from './set-upgradeable';
 
 function getHeader(c: Contract) {
   return [`// SPDX-License-Identifier: ${c.license}`, `pragma solidity ^${SOLIDITY_VERSION};`];
 }
 
-const test = (c: Contract, opts?: GenericOptions) => {
-  return formatLinesWithSpaces(2, ...spaceBetween(getHeader(c), getImports(c), getTestCase(c)));
+function shouldUseUnsafeAllowConstructor(c: Contract): boolean {
+  // TODO: remove that selector when the upgrades plugin supports @custom:oz-upgrades-unsafe-allow-reachable
+  return c.parents.find(p => ['EIP712'].includes(p.contract.name)) !== undefined;
+}
 
-  function getImports(c: Contract) {
-    const result = ['import {Test} from "forge-std/Test.sol";'];
-    if (c.upgradeable) {
-      result.push('import {Upgrades} from "openzeppelin-foundry-upgrades/Upgrades.sol";');
+function getImports(c: Contract, prepopulateImports: string[]): string[] {
+  const result: string[] = [...prepopulateImports];
+  if (c.upgradeable) {
+    const unsafeAllowConstructor = shouldUseUnsafeAllowConstructor(c);
+
+    result.push(
+      unsafeAllowConstructor
+        ? 'import {Upgrades, Options} from "openzeppelin-foundry-upgrades/Upgrades.sol";'
+        : 'import {Upgrades} from "openzeppelin-foundry-upgrades/Upgrades.sol";',
+    );
+  }
+  result.push(`import {${c.name}} from "src/${c.name}.sol";`);
+  return result;
+}
+
+function getDeploymentCode(
+  c: Contract,
+  args: string[],
+  declareContractVariable: boolean,
+  upgradeable?: Upgradeable,
+): Lines[] {
+  const unsafeAllowConstructor = shouldUseUnsafeAllowConstructor(c);
+  const instanceDeclaration = declareContractVariable ? `${c.name} ` : '';
+
+  switch (upgradeable) {
+    case 'transparent':
+      return printDeployProxyAndAssignInstance('deployTransparentProxy', true);
+    case 'uups':
+      return printDeployProxyAndAssignInstance('deployUUPSProxy', false);
+    default:
+      return [`${instanceDeclaration}instance = new ${c.name}(${args.join(', ')});`];
+  }
+
+  function printDeployProxyAndAssignInstance(deployProxyFunctionName: string, includeInitialOwner: boolean) {
+    const deployProxyArgs = [`"${c.name}.sol"`];
+    if (includeInitialOwner) {
+      deployProxyArgs.push('initialOwner');
+    }
+    deployProxyArgs.push(`abi.encodeCall(${c.name}.initialize, (${args.join(', ')}))`);
+    if (unsafeAllowConstructor) {
+      deployProxyArgs.push('opts');
+    }
+    for (let i = 0; i < deployProxyArgs.length - 1; i++) {
+      deployProxyArgs[i] += ',';
     }
-    result.push(`import {${c.name}} from "src/${c.name}.sol";`);
-    return result;
+
+    return [
+      unsafeAllowConstructor && 'Options memory opts;',
+      unsafeAllowConstructor && 'opts.unsafeAllow = "constructor";',
+      `address proxy = Upgrades.${deployProxyFunctionName}(`,
+      deployProxyArgs,
+      ');',
+      // Account has a receive function, this requires a payable address
+      c.parents.find(p => ['Account'].includes(p.contract.name))
+        ? `${instanceDeclaration}instance = ${c.name}(payable(proxy));`
+        : `${instanceDeclaration}instance = ${c.name}(proxy);`,
+    ].filter(line => line !== false);
   }
+}
+
+const test = (c: Contract, opts?: GenericOptions) => {
+  return formatLinesWithSpaces(
+    2,
+    ...spaceBetween(getHeader(c), getImports(c, ['import {Test} from "forge-std/Test.sol";']), getTestCase(c)),
+  );
 
   function getTestCase(c: Contract) {
     const args = getAddressArgs(c);
@@ -29,35 +89,18 @@ const test = (c: Contract, opts?: GenericOptions) => {
       `contract ${c.name}Test is Test {`,
       spaceBetween(
         [`${c.name} public instance;`],
-        ['function setUp() public {', getAddressVariables(c, args), getDeploymentCode(c, args), '}'],
+        [
+          'function setUp() public {',
+          getAddressVariables(c, args),
+          getDeploymentCode(c, args, false, opts?.upgradeable),
+          '}',
+        ],
         getContractSpecificTestFunction(),
       ),
       '}',
     ];
   }
 
-  function getDeploymentCode(c: Contract, args: string[]): Lines[] {
-    if (c.upgradeable) {
-      if (opts?.upgradeable === 'transparent') {
-        return [
-          `address proxy = Upgrades.deployTransparentProxy(`,
-          [`"${c.name}.sol",`, `initialOwner,`, `abi.encodeCall(${c.name}.initialize, (${args.join(', ')}))`],
-          ');',
-          `instance = ${c.name}(proxy);`,
-        ];
-      } else {
-        return [
-          `address proxy = Upgrades.deployUUPSProxy(`,
-          [`"${c.name}.sol",`, `abi.encodeCall(${c.name}.initialize, (${args.join(', ')}))`],
-          ');',
-          `instance = ${c.name}(proxy);`,
-        ];
-      }
-    } else {
-      return [`instance = new ${c.name}(${args.join(', ')});`];
-    }
-  }
-
   function getAddressVariables(c: Contract, args: string[]): Lines[] {
     const vars = [];
     let i = 1; // private key index starts from 1 since it must be non-zero
@@ -80,6 +123,7 @@ const test = (c: Contract, opts?: GenericOptions) => {
         case 'ERC1155':
           return ['function testUri() public view {', [`assertEq(instance.uri(0), "${opts.uri}");`], '}'];
 
+        case 'Account':
         case 'Governor':
         case 'Custom':
           return ['function testSomething() public {', ['// Add your test here'], '}'];
@@ -103,23 +147,21 @@ function getAddressArgs(c: Contract): string[] {
 }
 
 const script = (c: Contract, opts?: GenericOptions) => {
-  return formatLinesWithSpaces(2, ...spaceBetween(getHeader(c), getImports(c), getScript(c)));
-
-  function getImports(c: Contract) {
-    const result = ['import {Script} from "forge-std/Script.sol";', 'import {console} from "forge-std/console.sol";'];
-    if (c.upgradeable) {
-      result.push('import {Upgrades} from "openzeppelin-foundry-upgrades/Upgrades.sol";');
-    }
-    result.push(`import {${c.name}} from "src/${c.name}.sol";`);
-    return result;
-  }
+  return formatLinesWithSpaces(
+    2,
+    ...spaceBetween(
+      getHeader(c),
+      getImports(c, ['import {Script} from "forge-std/Script.sol";', 'import {console} from "forge-std/console.sol";']),
+      getScript(c),
+    ),
+  );
 
   function getScript(c: Contract) {
     const args = getAddressArgs(c);
     const deploymentLines = [
       'vm.startBroadcast();',
       ...getAddressVariables(c, args),
-      ...getDeploymentCode(c, args),
+      ...getDeploymentCode(c, args, true, opts?.upgradeable),
       `console.log("${c.upgradeable ? 'Proxy' : 'Contract'} deployed to %s", address(instance));`,
       'vm.stopBroadcast();',
     ];
@@ -133,28 +175,6 @@ const script = (c: Contract, opts?: GenericOptions) => {
     ];
   }
 
-  function getDeploymentCode(c: Contract, args: string[]): Lines[] {
-    if (c.upgradeable) {
-      if (opts?.upgradeable === 'transparent') {
-        return [
-          `address proxy = Upgrades.deployTransparentProxy(`,
-          [`"${c.name}.sol",`, `initialOwner,`, `abi.encodeCall(${c.name}.initialize, (${args.join(', ')}))`],
-          ');',
-          `${c.name} instance = ${c.name}(proxy);`,
-        ];
-      } else {
-        return [
-          `address proxy = Upgrades.deployUUPSProxy(`,
-          [`"${c.name}.sol",`, `abi.encodeCall(${c.name}.initialize, (${args.join(', ')}))`],
-          ');',
-          `${c.name} instance = ${c.name}(proxy);`,
-        ];
-      }
-    } else {
-      return [`${c.name} instance = new ${c.name}(${args.join(', ')});`];
-    }
-  }
-
   function getAddressVariables(c: Contract, args: string[]): Lines[] {
     const vars = [];
     if (c.upgradeable && opts?.upgradeable === 'transparent' && !args.includes('initialOwner')) {

package/src/zip-hardhat.ts

@@ -87,6 +87,7 @@ const test = (c: Contract, opts?: GenericOptions) => {
         case 'ERC1155':
           return [`expect(await instance.uri(0)).to.equal("${opts.uri}");`];
 
+        case 'Account':
         case 'Governor':
         case 'Custom':
           break;
@@ -118,9 +119,14 @@ function getAddressArgs(c: Contract): string[] {
 }
 
 function getDeploymentCall(c: Contract, args: string[]): string {
-  return c.upgradeable
-    ? `upgrades.deployProxy(ContractFactory, [${args.join(', ')}])`
-    : `ContractFactory.deploy(${args.join(', ')})`;
+  // TODO: remove that selector when the upgrades plugin supports @custom:oz-upgrades-unsafe-allow-reachable
+  const unsafeAllowConstructor = c.parents.find(p => ['EIP712'].includes(p.contract.name)) !== undefined;
+
+  return !c.upgradeable
+    ? `ContractFactory.deploy(${args.join(', ')})`
+    : unsafeAllowConstructor
+      ? `upgrades.deployProxy(ContractFactory, [${args.join(', ')}], { unsafeAllow: 'constructor' })`
+      : `upgrades.deployProxy(ContractFactory, [${args.join(', ')}])`;
 }
 
 const script = (c: Contract) => {