@openzeppelin/wizard 0.5.4 → 0.5.6

package/src/governor.ts

@@ -1,13 +1,13 @@
 import { supportsInterface } from './common-functions';
 import type { CommonOptions } from './common-options';
 import { withCommonDefaults, defaults as commonDefaults } from './common-options';
-import type { Contract } from './contract';
+import type { Contract, ImportContract } from './contract';
 import { ContractBuilder } from './contract';
 import { OptionsError } from './error';
 import { setAccessControl } from './set-access-control';
 import { printContract } from './print';
 import { setInfo } from './set-info';
-import { setUpgradeable } from './set-upgradeable';
+import { setUpgradeableGovernor } from './set-upgradeable';
 import { defineFunctions } from './utils/define-functions';
 import { durationToBlocks, durationToTimestamp } from './utils/duration';
 import { clockModeDefault, type ClockMode } from './set-clock-mode';
@@ -61,8 +61,8 @@ export interface GovernorOptions extends CommonOptions {
   settings?: boolean;
 }
 
-export function isAccessControlRequired(opts: Partial<GovernorOptions>): boolean {
-  return opts.upgradeable === 'uups';
+export function isAccessControlRequired(_: Partial<GovernorOptions>): boolean {
+  return false;
 }
 
 function withDefaults(opts: GovernorOptions): Required<GovernorOptions> {
@@ -99,21 +99,19 @@ export function buildGovernor(opts: GovernorOptions): Contract {
   addTimelock(c, allOpts);
 
   setAccessControl(c, allOpts.access);
-  setUpgradeable(c, allOpts.upgradeable, allOpts.access);
+  setUpgradeableGovernor(c, allOpts.upgradeable);
   setInfo(c, allOpts.info);
 
   return c;
 }
 
+const Governor: ImportContract = {
+  name: 'Governor',
+  path: '@openzeppelin/contracts/governance/Governor.sol',
+};
+
 function addBase(c: ContractBuilder, { name }: GovernorOptions) {
-  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);
@@ -221,6 +219,7 @@ function setVotingParameters(c: ContractBuilder, opts: Required<GovernorOptions>
   } else {
     c.setFunctionBody([`return ${delayBlocks.value}; // ${delayBlocks.note}`], functions.votingDelay);
   }
+  c.addOverride(Governor, functions.votingDelay);
 
   const periodBlocks = getVotingPeriod(opts);
   if ('lit' in periodBlocks) {
@@ -228,6 +227,7 @@ function setVotingParameters(c: ContractBuilder, opts: Required<GovernorOptions>
   } else {
     c.setFunctionBody([`return ${periodBlocks.value}; // ${periodBlocks.note}`], functions.votingPeriod);
   }
+  c.addOverride(Governor, functions.votingPeriod);
 }
 
 function setProposalThreshold(c: ContractBuilder, opts: Required<GovernorOptions>) {
@@ -308,6 +308,7 @@ function addQuorum(c: ContractBuilder, opts: Required<GovernorOptions>) {
         : `return ${opts.quorumAbsolute}e${opts.decimals};`;
 
     c.setFunctionBody([returnStatement], functions.quorum, 'pure');
+    c.addOverride(Governor, functions.quorum);
   }
 }
 

package/src/index.ts

@@ -19,6 +19,6 @@ export { OptionsError } from './error';
 export type { Kind } from './kind';
 export { sanitizeKind } from './kind';
 
-export { erc20, erc721, erc1155, stablecoin, realWorldAsset, governor, custom } from './api';
+export { erc20, erc721, erc1155, stablecoin, realWorldAsset, account, governor, custom } from './api';
 
 export { compatibleContractsSemver } from './utils/version';

package/src/kind.ts

@@ -4,7 +4,7 @@ export type Kind = GenericOptions['kind'];
 
 export function sanitizeKind(kind: unknown): Kind {
   if (typeof kind === 'string') {
-    const sanitized = kind.replace(/^(ERC|.)/i, c => c.toUpperCase());
+    const sanitized = kind.replace(/^(ERC|.)/i, c => c.toUpperCase()).replace(/^(RealWorldAsset)$/i, 'RealWorldAsset');
     if (isKind(sanitized)) {
       return sanitized;
     }
@@ -19,6 +19,7 @@ function isKind<T>(value: Kind | T): value is Kind {
     case 'ERC721':
     case 'Stablecoin':
     case 'RealWorldAsset':
+    case 'Account':
     case 'Governor':
     case 'Custom':
       return true;

package/src/print.ts

@@ -16,6 +16,7 @@ import { mapValues } from './utils/map-values';
 import SOLIDITY_VERSION from './solidity-version.json';
 import { inferTranspiled } from './infer-transpiled';
 import { compatibleContractsSemver } from './utils/version';
+import { stringifyUnicodeSafe } from './utils/sanitize';
 
 export function printContract(contract: Contract, opts?: Options): string {
   const helpers = withHelpers(contract, opts);
@@ -148,7 +149,7 @@ export function printValue(value: Value): string {
       throw new Error(`Number not representable (${value})`);
     }
   } else {
-    return JSON.stringify(value);
+    return stringifyUnicodeSafe(value);
   }
 }
 

package/src/set-upgradeable.ts

@@ -7,7 +7,11 @@ export const upgradeableOptions = [false, 'transparent', 'uups'] as const;
 
 export type Upgradeable = (typeof upgradeableOptions)[number];
 
-export function setUpgradeable(c: ContractBuilder, upgradeable: Upgradeable, access: Access) {
+function setUpgradeableBase(
+  c: ContractBuilder,
+  upgradeable: Upgradeable,
+  restrictAuthorizeUpgradeWhenUUPS: () => void,
+) {
   if (upgradeable === false) {
     return;
   }
@@ -24,7 +28,7 @@ export function setUpgradeable(c: ContractBuilder, upgradeable: Upgradeable, acc
       break;
 
     case 'uups': {
-      requireAccessControl(c, functions._authorizeUpgrade, access, 'UPGRADER', 'upgrader');
+      restrictAuthorizeUpgradeWhenUUPS();
       const UUPSUpgradeable = {
         name: 'UUPSUpgradeable',
         path: '@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol',
@@ -42,6 +46,18 @@ export function setUpgradeable(c: ContractBuilder, upgradeable: Upgradeable, acc
   }
 }
 
+export function setUpgradeable(c: ContractBuilder, upgradeable: Upgradeable, access: Access) {
+  setUpgradeableBase(c, upgradeable, () => {
+    requireAccessControl(c, functions._authorizeUpgrade, access, 'UPGRADER', 'upgrader');
+  });
+}
+
+export function setUpgradeableGovernor(c: ContractBuilder, upgradeable: Upgradeable) {
+  setUpgradeableBase(c, upgradeable, () => {
+    c.addModifier('onlyGovernance', functions._authorizeUpgrade);
+  });
+}
+
 const functions = defineFunctions({
   _authorizeUpgrade: {
     args: [{ name: 'newImplementation', type: 'address' }],

package/src/signer.ts

@@ -0,0 +1,124 @@
+import type { ContractBuilder } from './contract';
+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 {
+  if (!signer) return;
+  const parent = signers[signer];
+  const name = parent.name;
+  c.addParent(parent);
+  c.addOverride(
+    { name: name === signers.MultisigWeighted.name ? signers.Multisig.name : name },
+    signerFunctions._rawSignatureValidation,
+  );
+
+  // ERC-7702 doesn't require initialization
+  if (signer === 'ERC7702') return;
+
+  c.addParent({
+    name: 'Initializable',
+    path: '@openzeppelin/contracts/proxy/utils/Initializable.sol',
+  });
+  const fn = signerFunctions[`initialize${signer}`];
+  c.addModifier('initializer', fn);
+
+  const args = fn.args;
+
+  switch (signer) {
+    case 'Multisig':
+      c.addFunctionCode(`_addSigners(${args[0]!.name});`, fn);
+      c.addFunctionCode(`_setThreshold(${args[1]!.name});`, fn);
+      break;
+    case 'MultisigWeighted':
+      c.addFunctionCode(`_addSigners(${args[0]!.name});`, fn);
+      c.addFunctionCode(`_setSignerWeights(${args[0]!.name}, ${args[1]!.name});`, fn);
+      c.addFunctionCode(`_setThreshold(${args[2]!.name});`, fn);
+      break;
+    case 'ECDSA':
+    case 'P256':
+    case 'RSA':
+      c.addFunctionCode(
+        `_setSigner(${fn.args
+          .map(({ name }) => name)
+          .join(', ')
+          .trimEnd()});`,
+        fn,
+      );
+  }
+}
+
+export const signers = {
+  ERC7702: {
+    name: 'SignerERC7702',
+    path: '@openzeppelin/community-contracts/utils/cryptography/SignerERC7702.sol',
+  },
+  ECDSA: {
+    name: 'SignerECDSA',
+    path: '@openzeppelin/community-contracts/utils/cryptography/SignerECDSA.sol',
+  },
+  P256: {
+    name: 'SignerP256',
+    path: '@openzeppelin/community-contracts/utils/cryptography/SignerP256.sol',
+  },
+  RSA: {
+    name: 'SignerRSA',
+    path: '@openzeppelin/community-contracts/utils/cryptography/SignerRSA.sol',
+  },
+  Multisig: {
+    name: 'MultiSignerERC7913',
+    path: '@openzeppelin/community-contracts/utils/cryptography/MultiSignerERC7913.sol',
+  },
+  MultisigWeighted: {
+    name: 'MultiSignerERC7913Weighted',
+    path: '@openzeppelin/community-contracts/utils/cryptography/MultiSignerERC7913Weighted.sol',
+  },
+};
+
+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: [
+        { name: 'hash', type: 'bytes32' },
+        { name: 'signature', type: 'bytes calldata' },
+      ],
+      returns: ['bool'],
+      mutability: 'view' as const,
+    },
+  }),
+};

package/src/solidity-version.json

@@ -1 +1 @@
-"0.8.22"
+"0.8.27"

package/src/stablecoin.ts

@@ -65,7 +65,7 @@ function addLimitations(c: ContractBuilder, access: Access, mode: boolean | 'all
   const type = mode === 'allowlist';
   const ERC20Limitation = {
     name: type ? 'ERC20Allowlist' : 'ERC20Blocklist',
-    path: `@openzeppelin/community-contracts/contracts/token/ERC20/extensions/${type ? 'ERC20Allowlist' : 'ERC20Blocklist'}.sol`,
+    path: `@openzeppelin/community-contracts/token/ERC20/extensions/${type ? 'ERC20Allowlist' : 'ERC20Blocklist'}.sol`,
   };
 
   c.addParent(ERC20Limitation);
@@ -86,7 +86,7 @@ function addLimitations(c: ContractBuilder, access: Access, mode: boolean | 'all
 function addCustodian(c: ContractBuilder, access: Access) {
   const ERC20Custodian = {
     name: 'ERC20Custodian',
-    path: '@openzeppelin/community-contracts/contracts/token/ERC20/extensions/ERC20Custodian.sol',
+    path: '@openzeppelin/community-contracts/token/ERC20/extensions/ERC20Custodian.sol',
   };
 
   c.addParent(ERC20Custodian);

package/src/test.ts

@@ -30,6 +30,10 @@ test.serial('stablecoin result compiles', async t => {
   await testCompile(t, 'Stablecoin');
 });
 
+test.serial('account result compiles', async t => {
+  await testCompile(t, 'Account');
+});
+
 test.serial('governor result compiles', async t => {
   await testCompile(t, 'Governor');
 });
@@ -66,6 +70,8 @@ function isAccessControlRequired(opts: GenericOptions) {
       return stablecoin.isAccessControlRequired(opts);
     case 'RealWorldAsset':
       return stablecoin.isAccessControlRequired(opts);
+    case 'Account':
+      throw new Error(`Not applicable for ${opts.kind}`);
     case 'Governor':
       return governor.isAccessControlRequired(opts);
     case 'Custom':
@@ -79,11 +85,17 @@ test('is access control required', async t => {
   for (const contract of generateSources('all')) {
     const regexOwnable = /import.*Ownable(Upgradeable)?.sol.*/gm;
 
-    if (!contract.options.access) {
-      if (isAccessControlRequired(contract.options)) {
-        t.regex(contract.source, regexOwnable, JSON.stringify(contract.options));
-      } else {
-        t.notRegex(contract.source, regexOwnable, JSON.stringify(contract.options));
+    switch (contract.options.kind) {
+      case 'Account':
+        break;
+      default: {
+        if (!contract.options.access) {
+          if (isAccessControlRequired(contract.options)) {
+            t.regex(contract.source, regexOwnable, JSON.stringify(contract.options));
+          } else {
+            t.notRegex(contract.source, regexOwnable, JSON.stringify(contract.options));
+          }
+        }
       }
     }
   }

package/src/utils/sanitize.ts

@@ -0,0 +1,6 @@
+export function stringifyUnicodeSafe(str: string): string {
+  // eslint-disable-next-line no-control-regex
+  const containsUnicode = /[^\x00-\x7F]/.test(str);
+
+  return containsUnicode ? `unicode"${str.replace(/"/g, '\\"')}"` : JSON.stringify(str);
+}

package/src/zip-foundry.ts

@@ -202,18 +202,18 @@ then
   mv README.md README-oz.md
 
   # Initialize sample Foundry project
-  forge init --force --no-commit --quiet
+  forge init --force --quiet
 
 ${
   c.upgradeable
     ? `\
   # Install OpenZeppelin Contracts and Upgrades
-  forge install OpenZeppelin/openzeppelin-contracts-upgradeable@v${contracts.version} --no-commit --quiet
-  forge install OpenZeppelin/openzeppelin-foundry-upgrades --no-commit --quiet\
+  forge install OpenZeppelin/openzeppelin-contracts-upgradeable@v${contracts.version} --quiet
+  forge install OpenZeppelin/openzeppelin-foundry-upgrades --quiet\
 `
     : `\
   # Install OpenZeppelin Contracts
-  forge install OpenZeppelin/openzeppelin-contracts@v${contracts.version} --no-commit --quiet\
+  forge install OpenZeppelin/openzeppelin-contracts@v${contracts.version} --quiet\
 `
 }