@openzeppelin/wizard 0.8.1 → 0.10.0

package/src/erc721.ts

@@ -8,10 +8,12 @@ import { defineFunctions } from './utils/define-functions';
 import type { CommonOptions } from './common-options';
 import { withCommonDefaults, defaults as commonDefaults } from './common-options';
 import { setUpgradeable } from './set-upgradeable';
+import type { Upgradeable } from './set-upgradeable';
 import { setInfo } from './set-info';
 import { printContract } from './print';
 import type { ClockMode } from './set-clock-mode';
 import { clockModeDefault, setClockMode } from './set-clock-mode';
+import { setNamespacedStorage, toStorageStructInstantiation } from './set-namespaced-storage';
 
 export interface ERC721Options extends CommonOptions {
   name: string;
@@ -28,9 +30,11 @@ export interface ERC721Options extends CommonOptions {
    * Setting `true` is equivalent to 'blocknumber'. Setting a clock mode implies voting is enabled.
    */
   votes?: boolean | ClockMode;
+  namespacePrefix?: string;
 }
 
 export const defaults: Required<ERC721Options> = {
+  ...commonDefaults,
   name: 'MyToken',
   symbol: 'MTK',
   baseUri: '',
@@ -41,9 +45,7 @@ export const defaults: Required<ERC721Options> = {
   mintable: false,
   incremental: false,
   votes: false,
-  access: commonDefaults.access,
-  upgradeable: commonDefaults.upgradeable,
-  info: commonDefaults.info,
+  namespacePrefix: 'myProject',
 } as const;
 
 function withDefaults(opts: ERC721Options): Required<ERC721Options> {
@@ -58,6 +60,7 @@ function withDefaults(opts: ERC721Options): Required<ERC721Options> {
     mintable: opts.mintable ?? defaults.mintable,
     incremental: opts.incremental ?? defaults.incremental,
     votes: opts.votes ?? defaults.votes,
+    namespacePrefix: opts.namespacePrefix ?? defaults.namespacePrefix,
   };
 }
 
@@ -99,7 +102,7 @@ export function buildERC721(opts: ERC721Options): Contract {
   }
 
   if (allOpts.mintable) {
-    addMintable(c, access, allOpts.incremental, allOpts.uriStorage);
+    addMintable(c, access, allOpts.incremental, allOpts.uriStorage, allOpts.upgradeable, allOpts.namespacePrefix);
   }
 
   if (allOpts.votes) {
@@ -174,14 +177,27 @@ function addBurnable(c: ContractBuilder) {
   });
 }
 
-function addMintable(c: ContractBuilder, access: Access, incremental = false, uriStorage = false) {
+function addMintable(
+  c: ContractBuilder,
+  access: Access,
+  incremental = false,
+  uriStorage = false,
+  upgradeable: Upgradeable,
+  namespacePrefix: string,
+) {
   const fn = getMintFunction(incremental, uriStorage);
   requireAccessControl(c, fn, access, 'MINTER', 'minter');
-
   if (incremental) {
-    c.addVariable('uint256 private _nextTokenId;');
-    c.addFunctionCode('uint256 tokenId = _nextTokenId++;', fn);
-    c.addFunctionCode('_safeMint(to, tokenId);', fn);
+    if (!upgradeable) {
+      c.addStateVariable('uint256 private _nextTokenId;', upgradeable);
+      c.addFunctionCode('uint256 tokenId = _nextTokenId++;', fn);
+      c.addFunctionCode('_safeMint(to, tokenId);', fn);
+    } else {
+      setNamespacedStorage(c, ['uint256 _nextTokenId;'], namespacePrefix);
+      c.addFunctionCode(toStorageStructInstantiation(c.name), fn);
+      c.addFunctionCode('uint256 tokenId = $._nextTokenId++;', fn);
+      c.addFunctionCode('_safeMint(to, tokenId);', fn);
+    }
   } else {
     c.addFunctionCode('_safeMint(to, tokenId);', fn);
   }

package/src/generate/account.ts

@@ -8,7 +8,7 @@ const account = {
   signatureValidation: [false, 'ERC1271', 'ERC7739'] as const,
   ERC721Holder: [false, true] as const,
   ERC1155Holder: [false, true] as const,
-  signer: ['ERC7702', 'ECDSA', 'P256', 'RSA', 'Multisig', 'MultisigWeighted'] as const,
+  signer: ['ECDSA', 'EIP7702', 'P256', 'RSA', 'Multisig', 'MultisigWeighted'] as const,
   batchedExecution: [false, true] as const,
   ERC7579Modules: [false, 'AccountERC7579', 'AccountERC7579Hooked'] as const,
   access: [false] as const,

package/src/generate/erc20.ts

@@ -22,6 +22,7 @@ const blueprint = {
   crossChainBridging: crossChainBridgingOptions,
   access: accessOptions,
   upgradeable: upgradeableOptions,
+  namespacePrefix: ['myProject'],
   info: infoOptions,
 };
 

package/src/generate/erc721.ts

@@ -19,6 +19,7 @@ const blueprint = {
   incremental: booleans,
   access: accessOptions,
   upgradeable: upgradeableOptions,
+  namespacePrefix: ['myProject'],
   info: infoOptions,
   votes: [...booleans, ...clockModeOptions] as const,
 };

package/src/generate/stablecoin.ts

@@ -21,6 +21,7 @@ const erc20Basic = {
   crossChainBridging: [false] as const,
   access: [false] as const,
   info: [{}] as const,
+  namespacePrefix: ['myProject'],
 };
 
 const erc20Full = {
@@ -38,10 +39,11 @@ const erc20Full = {
   crossChainBridging: crossChainBridgingOptions,
   access: accessOptions,
   info: infoOptions,
+  namespacePrefix: ['myProject'],
 };
 
 const stablecoinExtensions = {
-  limitations: [false, 'allowlist', 'blocklist'] as const,
+  restrictions: [false, 'allowlist', 'blocklist'] as const,
   custodian: booleans,
   upgradeable: [false] as const,
 };

package/src/print.ts

@@ -6,6 +6,8 @@ import type {
   Value,
   NatspecTag,
   ImportContract,
+  ContractStruct,
+  VariableOrErrorDefinition,
 } from './contract';
 import type { Options, Helpers } from './options';
 import { withHelpers } from './options';
@@ -23,10 +25,9 @@ import { getCommunityContractsGitCommit } from './utils/community-contracts-git-
 export function printContract(contract: Contract, opts?: Options): string {
   const helpers = withHelpers(contract, opts);
 
+  const structs = contract.structs.map(_struct => printStruct(_struct));
   const fns = mapValues(sortedFunctions(contract), fns => fns.map(fn => printFunction(fn, helpers)));
-
   const hasOverrides = fns.override.some(l => l.length > 0);
-
   return formatLines(
     ...spaceBetween(
       [
@@ -42,7 +43,9 @@ export function printContract(contract: Contract, opts?: Options): string {
         [`contract ${contract.name}`, ...printInheritance(contract, helpers), '{'].join(' '),
 
         spaceBetween(
-          contract.variables,
+          ...structs,
+          printVariableOrErrorDefinitionsWithComments(contract.variableOrErrorDefinitions),
+          printVariableOrErrorDefinitionsWithoutComments(contract.variableOrErrorDefinitions),
           printConstructor(contract, helpers),
           ...fns.code,
           ...fns.modifiers,
@@ -56,6 +59,20 @@ export function printContract(contract: Contract, opts?: Options): string {
   );
 }
 
+function printVariableOrErrorDefinitionsWithComments(variableOrErrorDefinitions: VariableOrErrorDefinition[]): Lines[] {
+  const withComments = variableOrErrorDefinitions.filter(v => v.comments?.length);
+  // Spaces between each item that has comments
+  return spaceBetween(...withComments.map(v => [...v.comments!, v.code]));
+}
+
+function printVariableOrErrorDefinitionsWithoutComments(
+  variableOrErrorDefinitions: VariableOrErrorDefinition[],
+): Lines[] {
+  const withoutComments = variableOrErrorDefinitions.filter(v => !v.comments?.length);
+  // No spaces between items that don't have comments
+  return withoutComments.map(v => v.code);
+}
+
 function printCompatibleLibraryVersions(contract: Contract): string {
   let result = `// Compatible with OpenZeppelin Contracts ${compatibleContractsSemver}`;
   if (importsCommunityContracts(contract)) {
@@ -84,16 +101,20 @@ function printConstructor(contract: Contract, helpers: Helpers): Lines[] {
   if (hasParentParams || hasConstructorCode || (helpers.upgradeable && parentsWithInitializers.length > 0)) {
     if (helpers.upgradeable) {
       const upgradeableParents = parentsWithInitializers.filter(p => inferTranspiled(p.contract));
-      const nonUpgradeableParents = contract.parents.filter(p => !inferTranspiled(p.contract));
+      // Omit Initializable and UUPSUpgradeable since they don't have explicit constructors
+      const nonUpgradeableParentsWithConstructors = contract.parents.filter(
+        p =>
+          !inferTranspiled(p.contract) && p.contract.name !== 'Initializable' && p.contract.name !== 'UUPSUpgradeable',
+      );
       const constructor = printFunction2(
         [
-          nonUpgradeableParents.length > 0
+          nonUpgradeableParentsWithConstructors.length > 0
             ? '/// @custom:oz-upgrades-unsafe-allow-reachable constructor'
             : '/// @custom:oz-upgrades-unsafe-allow constructor',
         ],
         'constructor',
         [],
-        nonUpgradeableParents.flatMap(p => printParentConstructor(p, helpers)),
+        nonUpgradeableParentsWithConstructors.flatMap(p => printParentConstructor(p, helpers)),
         ['_disableInitializers();'],
       );
       const initializer = printFunction2(
@@ -258,6 +279,20 @@ function printFunction2(
   return fn;
 }
 
+function printStruct(_struct: ContractStruct): Lines[] {
+  const [comments, kindedName, code] = [_struct.comments, _struct.name, _struct.variables];
+  const struct: Lines[] = [...comments];
+
+  const braces = code.length > 0 ? '{' : '{}';
+  struct.push([`struct ${kindedName}`, braces].join(' '));
+
+  if (code.length > 0) {
+    struct.push(code, '}');
+  }
+
+  return struct;
+}
+
 function printArgument(arg: FunctionArgument, { transformName }: Helpers): string {
   let type: string;
   if (typeof arg.type === 'string') {

package/src/set-access-control.ts

@@ -65,7 +65,9 @@ export function requireAccessControl(
     }
     case 'roles': {
       const roleId = roleIdPrefix + '_ROLE';
-      const addedConstant = c.addVariable(`bytes32 public constant ${roleId} = keccak256("${roleId}");`);
+      const addedConstant = c.addConstantOrImmutableOrErrorDefinition(
+        `bytes32 public constant ${roleId} = keccak256("${roleId}");`,
+      );
       if (roleOwner && addedConstant) {
         c.addConstructorArgument({ type: 'address', name: roleOwner });
         c.addConstructorCode(`_grantRole(${roleId}, ${roleOwner});`);

package/src/set-namespaced-storage.ts

@@ -0,0 +1,69 @@
+import type { BaseFunction, ContractBuilder, ContractStruct } from './contract';
+import { computeNamespacedStorageSlot } from './utils/namespaced-slot';
+import { OptionsError } from './error';
+
+/**
+ * Sets namespaced variables in storage struct, and adds a function to retrieve namespaced storage.
+ */
+export function setNamespacedStorage(c: ContractBuilder, structVariables: string[], namespacePrefix: string) {
+  validateNoWhitespace(namespacePrefix);
+
+  const namespaceId = toNamespaceId(namespacePrefix, c.name);
+  const storageFn = makeStorageFunction(c.name);
+  const storageStruct = makeStorageStruct(c.name, namespaceId);
+  const namespacedStorageConstant = `${c.name.toUpperCase()}_STORAGE_LOCATION`;
+
+  structVariables.forEach(v => c.addStructVariable(storageStruct, v));
+
+  c.addConstantOrImmutableOrErrorDefinition(
+    `bytes32 private constant ${namespacedStorageConstant} = ${computeNamespacedStorageSlot(namespaceId)};`,
+    [`// keccak256(abi.encode(uint256(keccak256("${namespaceId}")) - 1)) & ~bytes32(uint256(0xff))`],
+  );
+  c.addFunctionCode(`assembly { $.slot := ${namespacedStorageConstant} }`, storageFn);
+}
+
+export function toStorageStructInstantiation(name: string) {
+  return `${name}Storage storage $ = ${makeStorageFunction(name).name}();`;
+}
+
+/**
+ * According to ERC-7201, namespace ids should not contain any whitespace characters.
+ */
+function validateNoWhitespace(namespacePrefix: string) {
+  if (namespacePrefix.match(/\s+/)) {
+    throw new OptionsError({ namespacePrefix: 'Namespace prefix should not contain whitespace characters' });
+  }
+}
+
+/**
+ * Creates a namespace ID from a namespace prefix and a contract name.
+ * If the namespace prefix is empty, returns the contract name.
+ */
+function toNamespaceId(namespacePrefix: string, name: string) {
+  if (namespacePrefix.length === 0) {
+    return name;
+  } else {
+    return `${namespacePrefix}.${name}`;
+  }
+}
+
+function makeStorageFunction(name: string): BaseFunction {
+  const fn: BaseFunction = {
+    name: `_get${name}Storage`,
+    kind: 'private' as const,
+    mutability: 'pure',
+    args: [],
+    returns: [`${name}Storage storage $`],
+  };
+
+  return fn;
+}
+
+function makeStorageStruct(name: string, namespaceId: string) {
+  const struct: ContractStruct = {
+    name: `${name}Storage`,
+    comments: [`/// @custom:storage-location erc7201:${namespaceId}`],
+    variables: [],
+  };
+  return struct;
+}

package/src/set-upgradeable.ts

@@ -21,6 +21,7 @@ function setUpgradeableBase(
   c.addParent({
     name: 'Initializable',
     path: '@openzeppelin/contracts/proxy/utils/Initializable.sol',
+    transpiled: false,
   });
 
   switch (upgradeable) {
@@ -32,6 +33,7 @@ function setUpgradeableBase(
       const UUPSUpgradeable = {
         name: 'UUPSUpgradeable',
         path: '@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol',
+        transpiled: false,
       };
       c.addParent(UUPSUpgradeable);
       c.addOverride(UUPSUpgradeable, functions._authorizeUpgrade);

package/src/signer.ts

@@ -3,7 +3,7 @@ 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 const SignerOptions = [false, 'ECDSA', 'EIP7702', 'P256', 'RSA', 'Multisig', 'MultisigWeighted'] as const;
 export type SignerOptions = (typeof SignerOptions)[number];
 
 export function addSigner(c: ContractBuilder, signer: SignerOptions, upgradeable: Upgradeable): void {
@@ -13,11 +13,11 @@ export function addSigner(c: ContractBuilder, signer: SignerOptions, upgradeable
   c.addOverride({ name: signerName }, signerFunctions._rawSignatureValidation);
 
   switch (signer) {
-    case 'ERC7702':
+    case 'EIP7702':
       c.addParent(signers[signer]);
       if (upgradeable) {
         throw new OptionsError({
-          erc7702: 'EOAs can upgrade by redelegating to a new account',
+          eip7702: 'EOAs can upgrade by redelegating to a new account',
           upgradeable: 'EOAs can upgrade by redelegating to a new account',
         });
       }
@@ -38,14 +38,14 @@ export function addSigner(c: ContractBuilder, signer: SignerOptions, upgradeable
 }
 
 export const signers = {
-  ERC7702: {
-    name: 'SignerERC7702',
-    path: '@openzeppelin/contracts/utils/cryptography/signers/SignerERC7702.sol',
-  },
   ECDSA: {
     name: 'SignerECDSA',
     path: '@openzeppelin/contracts/utils/cryptography/signers/SignerECDSA.sol',
   },
+  EIP7702: {
+    name: 'SignerEIP7702',
+    path: '@openzeppelin/contracts/utils/cryptography/signers/SignerEIP7702.sol',
+  },
   P256: {
     name: 'SignerP256',
     path: '@openzeppelin/contracts/utils/cryptography/signers/SignerP256.sol',
@@ -64,7 +64,7 @@ export const signers = {
   },
 };
 
-export const signerArgs: Record<Exclude<SignerOptions, false | 'ERC7702'>, { name: string; type: string }[]> = {
+export const signerArgs: Record<Exclude<SignerOptions, false | 'EIP7702'>, { name: string; type: string }[]> = {
   ECDSA: [{ name: 'signer', type: 'address' }],
   P256: [
     { name: 'qx', type: 'bytes32' },

package/src/stablecoin.ts

@@ -12,7 +12,7 @@ import {
 } from './erc20';
 
 export interface StablecoinOptions extends ERC20Options {
-  limitations?: false | 'allowlist' | 'blocklist';
+  restrictions?: false | 'allowlist' | 'blocklist';
   custodian?: boolean;
 }
 
@@ -20,7 +20,7 @@ export const defaults: Required<StablecoinOptions> = {
   ...erc20defaults,
   name: 'MyStablecoin',
   symbol: 'MST',
-  limitations: false,
+  restrictions: false,
   custodian: false,
 } as const;
 
@@ -29,7 +29,7 @@ function withDefaults(opts: StablecoinOptions): Required<StablecoinOptions> {
     ...withERC20Defaults(opts),
     name: opts.name ?? defaults.name,
     symbol: opts.symbol ?? defaults.symbol,
-    limitations: opts.limitations ?? defaults.limitations,
+    restrictions: opts.restrictions ?? defaults.restrictions,
     custodian: opts.custodian ?? defaults.custodian,
   };
 }
@@ -39,7 +39,7 @@ export function printStablecoin(opts: StablecoinOptions = defaults): string {
 }
 
 export function isAccessControlRequired(opts: Partial<StablecoinOptions>): boolean {
-  return opts.mintable || opts.limitations !== false || opts.custodian || opts.pausable || opts.upgradeable === 'uups';
+  return opts.mintable || opts.restrictions !== false || opts.custodian || opts.pausable || opts.upgradeable === 'uups';
 }
 
 export function buildStablecoin(opts: StablecoinOptions): Contract {
@@ -54,33 +54,37 @@ export function buildStablecoin(opts: StablecoinOptions): Contract {
     addCustodian(c, allOpts.access);
   }
 
-  if (allOpts.limitations) {
-    addLimitations(c, allOpts.access, allOpts.limitations);
+  if (allOpts.restrictions) {
+    addRestrictions(c, allOpts.access, allOpts.restrictions);
   }
 
   return c;
 }
 
-function addLimitations(c: ContractBuilder, access: Access, mode: boolean | 'allowlist' | 'blocklist') {
-  const type = mode === 'allowlist';
-  const ERC20Limitation = {
-    name: type ? 'ERC20Allowlist' : 'ERC20Blocklist',
-    path: `@openzeppelin/community-contracts/token/ERC20/extensions/${type ? 'ERC20Allowlist' : 'ERC20Blocklist'}.sol`,
+function addRestrictions(c: ContractBuilder, access: Access, mode: 'allowlist' | 'blocklist') {
+  const isAllowlist = mode === 'allowlist';
+  const ERC20Restricted = {
+    name: 'ERC20Restricted',
+    path: `@openzeppelin/community-contracts/token/ERC20/extensions/ERC20Restricted.sol`,
   };
 
-  c.addParent(ERC20Limitation);
-  c.addOverride(ERC20Limitation, functions._update);
-  c.addOverride(ERC20Limitation, functions._approve);
+  c.addParent(ERC20Restricted);
+  c.addOverride(ERC20Restricted, functions._update);
 
-  const [addFn, removeFn] = type
+  if (isAllowlist) {
+    c.addOverride(ERC20Restricted, functions.isUserAllowed);
+    c.setFunctionBody([`return getRestriction(user) == Restriction.ALLOWED;`], functions.isUserAllowed);
+  }
+
+  const [addFn, removeFn] = isAllowlist
     ? [functions.allowUser, functions.disallowUser]
     : [functions.blockUser, functions.unblockUser];
 
   requireAccessControl(c, addFn, access, 'LIMITER', 'limiter');
-  c.addFunctionCode(`_${type ? 'allowUser' : 'blockUser'}(user);`, addFn);
+  c.addFunctionCode(`_${isAllowlist ? 'allow' : 'block'}User(user);`, addFn);
 
   requireAccessControl(c, removeFn, access, 'LIMITER', 'limiter');
-  c.addFunctionCode(`_${type ? 'disallowUser' : 'unblockUser'}(user);`, removeFn);
+  c.addFunctionCode(`_resetUser(user);`, removeFn);
 }
 
 function addCustodian(c: ContractBuilder, access: Access) {
@@ -107,7 +111,9 @@ function addCustodian(c: ContractBuilder, access: Access) {
     case 'roles': {
       const roleOwner = 'custodian';
       const roleId = 'CUSTODIAN_ROLE';
-      const addedConstant = c.addVariable(`bytes32 public constant ${roleId} = keccak256("${roleId}");`);
+      const addedConstant = c.addConstantOrImmutableOrErrorDefinition(
+        `bytes32 public constant ${roleId} = keccak256("${roleId}");`,
+      );
       if (roleOwner && addedConstant) {
         c.addConstructorArgument({ type: 'address', name: roleOwner });
         c.addConstructorCode(`_grantRole(${roleId}, ${roleOwner});`);
@@ -159,5 +165,12 @@ const functions = {
       kind: 'public' as const,
       args: [{ name: 'user', type: 'address' }],
     },
+
+    isUserAllowed: {
+      kind: 'public' as const,
+      args: [{ name: 'user', type: 'address' }],
+      returns: ['bool'],
+      mutability: 'view' as const,
+    },
   }),
 };

package/src/utils/namespaced-slot.ts

@@ -0,0 +1,18 @@
+import { keccak256 } from 'ethereum-cryptography/keccak';
+import { hexToBytes, toHex, utf8ToBytes } from 'ethereum-cryptography/utils';
+
+/**
+ * Returns the ERC-7201 storage location for a given namespace id
+ */
+export function computeNamespacedStorageSlot(id: string): string {
+  const innerHash = keccak256(utf8ToBytes(id));
+  const minusOne = BigInt('0x' + toHex(innerHash)) - 1n;
+  const minusOneBytes = hexToBytes(minusOne.toString(16).padStart(64, '0'));
+
+  const outerHash = keccak256(minusOneBytes);
+
+  const mask = BigInt('0xff');
+  const masked = BigInt('0x' + toHex(outerHash)) & ~mask;
+
+  return '0x' + masked.toString(16).padStart(64, '0');
+}

package/src/utils/version.ts

@@ -1,4 +1,4 @@
 /**
  * Semantic version string representing of the minimum compatible version of Contracts to display in output.
  */
-export const compatibleContractsSemver = '^5.4.0';
+export const compatibleContractsSemver = '^5.5.0';

package/src/zip-hardhat.ts

@@ -15,6 +15,7 @@ const config: HardhatUserConfig = {
   solidity: {
     version: "${SOLIDITY_VERSION}",
     settings: {
+      evmVersion: 'cancun',
       optimizer: {
         enabled: true,
       },