@openzeppelin/wizard 0.8.0 → 0.9.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/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,6 +39,7 @@ const erc20Full = {
   crossChainBridging: crossChainBridgingOptions,
   access: accessOptions,
   info: infoOptions,
+  namespacePrefix: ['myProject'],
 };
 
 const stablecoinExtensions = {

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)) {
@@ -258,6 +275,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/stablecoin.ts

@@ -107,7 +107,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});`);

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');
+}