@openzeppelin/wizard 0.1.0 → 0.2.0

package/src/environments/hardhat/upgradeable/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "hardhat-sample",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "hardhat test"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@openzeppelin/contracts-upgradeable": "^4.8.0",
+    "@openzeppelin/hardhat-upgrades": "^1.21.0",
+    "@ethersproject/abi": "^5.7.0",
+    "@ethersproject/providers": "^5.7.2",
+    "@nomicfoundation/hardhat-chai-matchers": "^1.0.4",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.6",
+    "@nomicfoundation/hardhat-toolbox": "^2.0.0",
+    "@nomiclabs/hardhat-ethers": "^2.2.0",
+    "@nomiclabs/hardhat-etherscan": "^3.1.1",
+    "@typechain/ethers-v5": "^10.1.1",
+    "@typechain/hardhat": "^6.1.4",
+    "@types/chai": "^4.3.3",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.11.6",
+    "chai": "^4.3.6",
+    "ethers": "^5.7.2",
+    "hardhat": "^2.12.0",
+    "hardhat-gas-reporter": "^1.0.9",
+    "solidity-coverage": "^0.8.2",
+    "ts-node": "^10.9.1",
+    "typechain": "^8.1.1",
+    "typescript": "^4.8.4"
+  }
+}

package/src/erc1155.ts

@@ -1,5 +1,5 @@
 import { Contract, ContractBuilder } from './contract';
-import { Access, setAccessControl } from './set-access-control';
+import { Access, setAccessControl, requireAccessControl } from './set-access-control';
 import { addPausable } from './add-pausable';
 import { supportsInterface } from './common-functions';
 import { defineFunctions } from './utils/define-functions';
@@ -15,6 +15,7 @@ export interface ERC1155Options extends CommonOptions {
   pausable?: boolean;
   mintable?: boolean;
   supply?: boolean;
+  updatableUri?: boolean;
 }
 
 export const defaults: Required<ERC1155Options> = {
@@ -24,7 +25,8 @@ export const defaults: Required<ERC1155Options> = {
   pausable: false,
   mintable: false,
   supply: false,
-  access: commonDefaults.access,
+  updatableUri: true,
+  access: false,
   upgradeable: commonDefaults.upgradeable,
   info: commonDefaults.info
 } as const;
@@ -37,6 +39,7 @@ function withDefaults(opts: ERC1155Options): Required<ERC1155Options> {
     pausable: opts.pausable ?? defaults.pausable,
     mintable: opts.mintable ?? defaults.mintable,
     supply: opts.supply ?? defaults.supply,
+    updatableUri: opts.updatableUri ?? defaults.updatableUri,
   };
 }
 
@@ -44,6 +47,10 @@ export function printERC1155(opts: ERC1155Options = defaults): string {
   return printContract(buildERC1155(opts));
 }
 
+export function isAccessControlRequired(opts: Partial<ERC1155Options>): boolean {
+  return opts.mintable || opts.pausable || opts.updatableUri !== false || opts.upgradeable === 'uups';
+}
+
 export function buildERC1155(opts: ERC1155Options): Contract {
   const allOpts = withDefaults(opts);
 
@@ -52,7 +59,10 @@ export function buildERC1155(opts: ERC1155Options): Contract {
   const { access, upgradeable, info } = allOpts;
 
   addBase(c, allOpts.uri);
-  addSetUri(c, access);
+
+  if (allOpts.updatableUri) {
+    addSetUri(c, access);
+  }
 
   if (allOpts.pausable) {
     addPausable(c, access, [functions._beforeTokenTransfer]);
@@ -70,8 +80,8 @@ export function buildERC1155(opts: ERC1155Options): Contract {
     addSupply(c);
   }
 
+  setAccessControl(c, access);
   setUpgradeable(c, upgradeable, access);
-
   setInfo(c, info);
 
   return c;
@@ -98,14 +108,14 @@ function addBurnable(c: ContractBuilder) {
 }
 
 function addMintable(c: ContractBuilder, access: Access) {
-  setAccessControl(c, functions.mint, access, 'MINTER');
-  setAccessControl(c, functions.mintBatch, access, 'MINTER');
+  requireAccessControl(c, functions.mint, access, 'MINTER');
+  requireAccessControl(c, functions.mintBatch, access, 'MINTER');
   c.addFunctionCode('_mint(account, id, amount, data);', functions.mint);
   c.addFunctionCode('_mintBatch(to, ids, amounts, data);', functions.mintBatch);
 }
 
 function addSetUri(c: ContractBuilder, access: Access) {
-  setAccessControl(c, functions.setURI, access, 'URI_SETTER');
+  requireAccessControl(c, functions.setURI, access, 'URI_SETTER');
   c.addFunctionCode('_setURI(newuri);', functions.setURI);
 }
 

package/src/erc20.ts

@@ -1,5 +1,5 @@
 import { Contract, ContractBuilder } from './contract';
-import { Access, setAccessControl } from './set-access-control';
+import { Access, setAccessControl, requireAccessControl } from './set-access-control';
 import { addPausable } from './add-pausable';
 import { defineFunctions } from './utils/define-functions';
 import { CommonOptions, withCommonDefaults, defaults as commonDefaults } from './common-options';
@@ -55,6 +55,10 @@ export function printERC20(opts: ERC20Options = defaults): string {
   return printContract(buildERC20(opts));
 }
 
+export function isAccessControlRequired(opts: Partial<ERC20Options>): boolean {
+  return opts.mintable || opts.pausable || opts.snapshots || opts.upgradeable === 'uups';
+}
+
 export function buildERC20(opts: ERC20Options): Contract {
   const allOpts = withDefaults(opts);
 
@@ -97,8 +101,8 @@ export function buildERC20(opts: ERC20Options): Contract {
     addFlashMint(c);
   }
 
+  setAccessControl(c, access);
   setUpgradeable(c, upgradeable, access);
-  
   setInfo(c, info);
 
   return c;
@@ -134,7 +138,7 @@ function addSnapshot(c: ContractBuilder, access: Access) {
 
   c.addOverride('ERC20Snapshot', functions._beforeTokenTransfer);
 
-  setAccessControl(c, functions.snapshot, access, 'SNAPSHOT');
+  requireAccessControl(c, functions.snapshot, access, 'SNAPSHOT');
   c.addFunctionCode('_snapshot();', functions.snapshot);
 }
 
@@ -158,7 +162,7 @@ function addPremint(c: ContractBuilder, amount: string) {
 }
 
 function addMintable(c: ContractBuilder, access: Access) {
-  setAccessControl(c, functions.mint, access, 'MINTER');
+  requireAccessControl(c, functions.mint, access, 'MINTER');
   c.addFunctionCode('_mint(to, amount);', functions.mint);
 }
 

package/src/erc721.ts

@@ -1,5 +1,5 @@
 import { Contract, ContractBuilder } from './contract';
-import { Access, setAccessControl } from './set-access-control';
+import { Access, setAccessControl, requireAccessControl } from './set-access-control';
 import { addPausable } from './add-pausable';
 import { supportsInterface } from './common-functions';
 import { defineFunctions } from './utils/define-functions';
@@ -56,6 +56,10 @@ export function printERC721(opts: ERC721Options = defaults): string {
   return printContract(buildERC721(opts));
 }
 
+export function isAccessControlRequired(opts: Partial<ERC721Options>): boolean {
+  return opts.mintable || opts.pausable || opts.upgradeable === 'uups';
+}
+
 export function buildERC721(opts: ERC721Options): Contract {
   const allOpts = withDefaults(opts);
 
@@ -93,8 +97,8 @@ export function buildERC721(opts: ERC721Options): Contract {
     addVotes(c, allOpts.name);
   }
 
+  setAccessControl(c, access);
   setUpgradeable(c, upgradeable, access);
-
   setInfo(c, info);
 
   return c;
@@ -150,7 +154,7 @@ function addBurnable(c: ContractBuilder) {
 
 function addMintable(c: ContractBuilder, access: Access, incremental = false, uriStorage = false) {
   const fn = getMintFunction(incremental, uriStorage);
-  setAccessControl(c, fn, access, 'MINTER');
+  requireAccessControl(c, fn, access, 'MINTER');
 
   if (incremental) {
     c.addUsing({
@@ -193,6 +197,7 @@ const functions = defineFunctions({
       { name: 'from', type: 'address' },
       { name: 'to', type: 'address' },
       { name: 'tokenId', type: 'uint256' },
+      { name: 'batchSize', type: 'uint256' },
     ],
   },
 
@@ -202,6 +207,7 @@ const functions = defineFunctions({
       { name: 'from', type: 'address' },
       { name: 'to', type: 'address' },
       { name: 'tokenId', type: 'uint256' },
+      { name: 'batchSize', type: 'uint256' },
     ],
   },
 

package/src/generate/custom.ts

@@ -0,0 +1,19 @@
+import type { CustomOptions } from '../custom';
+import { accessOptions } from '../set-access-control';
+import { infoOptions } from '../set-info';
+import { upgradeableOptions } from '../set-upgradeable';
+import { generateAlternatives } from './alternatives';
+
+const booleans = [true, false];
+
+const blueprint = {
+  name: ['MyContract'],
+  pausable: booleans,
+  access: accessOptions,
+  upgradeable: upgradeableOptions,
+  info: infoOptions,
+};
+
+export function* generateCustomOptions(): Generator<Required<CustomOptions>> {
+  yield* generateAlternatives(blueprint);
+}

package/src/generate/erc1155.ts

@@ -13,6 +13,7 @@ const blueprint = {
   pausable: booleans,
   mintable: booleans,
   supply: booleans,
+  updatableUri: booleans,
   access: accessOptions,
   upgradeable: upgradeableOptions,
   info: infoOptions,

package/src/generate/sources.ts

@@ -5,9 +5,10 @@ import crypto from 'crypto';
 import { generateERC20Options } from './erc20';
 import { generateERC721Options } from './erc721';
 import { generateERC1155Options } from './erc1155';
+import { generateGovernorOptions } from './governor';
+import { generateCustomOptions } from './custom';
 import { buildGeneric, GenericOptions } from '../build-generic';
 import { printContract } from '../print';
-import { generateGovernorOptions } from './governor';
 import { OptionsError } from '../error';
 import { findCover } from '../utils/find-cover';
 import type { Contract } from '../contract';
@@ -30,6 +31,10 @@ export function* generateOptions(): Generator<GenericOptions> {
   for (const kindOpts of generateGovernorOptions()) {
     yield { kind: 'Governor', ...kindOpts };
   }
+
+  for (const kindOpts of generateCustomOptions()) {
+    yield { kind: 'Custom', ...kindOpts };
+  }
 }
 
 interface GeneratedContract {

package/src/governor.ts

@@ -2,6 +2,7 @@ import { supportsInterface } from "./common-functions";
 import { CommonOptions, withCommonDefaults, defaults as commonDefaults } from "./common-options";
 import { ContractBuilder, Contract } 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";
@@ -15,7 +16,7 @@ export const defaults: Required<GovernorOptions> = {
 
   votes: 'erc20votes',
   timelock: 'openzeppelin',
-  blockTime: 13.2,
+  blockTime: 12,
   decimals: 18,
   proposalThreshold: '0',
   quorumMode: 'percent',
@@ -55,6 +56,10 @@ export interface GovernorOptions extends CommonOptions {
   settings?: boolean;
 }
 
+export function isAccessControlRequired(opts: Partial<GovernorOptions>): boolean {
+  return opts.upgradeable === 'uups';
+}
+
 function withDefaults(opts: GovernorOptions): Required<GovernorOptions> {
   return {
     ...opts,
@@ -87,8 +92,8 @@ export function buildGovernor(opts: GovernorOptions): Contract {
   addQuorum(c, allOpts);
   addTimelock(c, allOpts);
 
+  setAccessControl(c, allOpts.access);
   setUpgradeable(c, allOpts.upgradeable, allOpts.access);
-
   setInfo(c, allOpts.info);
 
   return c;

package/src/index.ts

@@ -20,4 +20,4 @@ export { OptionsError } from './error';
 export type { Kind } from './kind';
 export { sanitizeKind } from './kind';
 
-export { erc20, erc721, erc1155, governor } from './api';
+export { erc20, erc721, erc1155, governor, custom } from './api';

package/src/kind.ts

@@ -18,6 +18,7 @@ function isKind<T>(value: Kind | T): value is Kind {
     case 'ERC1155':
     case 'ERC721':
     case 'Governor':
+    case 'Custom':
       return true;
 
     default: {

package/src/print.ts

@@ -5,8 +5,7 @@ import { Options, Helpers, withHelpers } from './options';
 
 import { formatLines, spaceBetween, Lines } from './utils/format-lines';
 import { mapValues } from './utils/map-values';
-
-const SOLIDITY_VERSION = '0.8.4';
+import SOLIDITY_VERSION from './solidity-version.json';
 
 export function printContract(contract: Contract, opts?: Options): string {
   const helpers = withHelpers(contract, opts);
@@ -64,9 +63,9 @@ function printUsingFor(contract: Contract, { transformName }: Helpers): string[]
 function printConstructor(contract: Contract, helpers: Helpers): Lines[] {
   const hasParentParams = contract.parents.some(p => p.params.length > 0);
   const hasConstructorCode = contract.constructorCode.length > 0;
-  if (hasParentParams || hasConstructorCode) {
-    const parents = contract.parents
-      .filter(hasInitializer)
+  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 ? ['initializer public'] : parents;
     const args = contract.constructorArgs.map(a =>  printArgument(a, helpers));
@@ -87,22 +86,27 @@ function printConstructor(contract: Contract, helpers: Helpers): Lines[] {
       return constructor;
     } else {
       return spaceBetween(
-        [
-          '/// @custom:oz-upgrades-unsafe-allow constructor',
-          'constructor() {',
-          [
-            '_disableInitializers();'
-          ],
-          '}'
-        ],
+        DISABLE_INITIALIZERS,
         constructor,
       );
     }
-  } else {
+  } else if (!helpers.upgradeable) {
     return [];
+  } else {
+    return DISABLE_INITIALIZERS;
   }
 }
 
+const DISABLE_INITIALIZERS = 
+[
+  '/// @custom:oz-upgrades-unsafe-allow constructor',
+  'constructor() {',
+  [
+    '_disableInitializers();'
+  ],
+  '}'
+];
+
 function hasInitializer(parent: Parent) {
   // CAUTION
   // This list is validated by compilation of SafetyCheck.sol.

package/src/set-access-control.ts

@@ -1,23 +1,46 @@
 import type { ContractBuilder, BaseFunction } from './contract';
 import { supportsInterface } from './common-functions';
 
-export const accessOptions = ['ownable', 'roles'] as const;
+export const accessOptions = [false, 'ownable', 'roles'] as const;
 
 export type Access = typeof accessOptions[number];
 
-export function setAccessControl(c: ContractBuilder, fn: BaseFunction, access: Access, role: string) {
+/**
+ * Sets access control for the contract by adding inheritance.
+ */
+export function setAccessControl(c: ContractBuilder, access: Access) {
   switch (access) {
     case 'ownable': {
       c.addParent(parents.Ownable);
-      c.addModifier('onlyOwner', fn);
       break;
     }
     case 'roles': {
-      const roleId = role + '_ROLE';
       if (c.addParent(parents.AccessControl)) {
         c.addConstructorCode('_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);');
       }
       c.addOverride(parents.AccessControl.name, supportsInterface);
+      break;
+    }
+  }
+}
+
+/**
+ * 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) {
+  if (access === false) {
+    access = 'ownable';
+  }
+  
+  setAccessControl(c, access);
+
+  switch (access) {
+    case 'ownable': {
+      c.addModifier('onlyOwner', fn);
+      break;
+    }
+    case 'roles': {
+      const roleId = role + '_ROLE';
       if (c.addVariable(`bytes32 public constant ${roleId} = keccak256("${roleId}");`)) {
         c.addConstructorCode(`_grantRole(${roleId}, msg.sender);`);
       }

package/src/set-upgradeable.ts

@@ -1,5 +1,5 @@
 import type { ContractBuilder } from './contract';
-import { Access, setAccessControl } from './set-access-control';
+import { Access, requireAccessControl } from './set-access-control';
 import { defineFunctions } from './utils/define-functions';
 
 export const upgradeableOptions = [false, 'transparent', 'uups'] as const;
@@ -22,7 +22,7 @@ export function setUpgradeable(c: ContractBuilder, upgradeable: Upgradeable, acc
     case 'transparent': break;
 
     case 'uups': {
-      setAccessControl(c, functions._authorizeUpgrade, access, 'UPGRADER');
+      requireAccessControl(c, functions._authorizeUpgrade, access, 'UPGRADER');
       c.addParent({
         name: 'UUPSUpgradeable',
         path: '@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol',

package/src/solidity-version.json

@@ -0,0 +1 @@
+"0.8.9"

package/src/test.ts

@@ -1,9 +1,10 @@
 import test from 'ava';
 import hre from 'hardhat';
-import { promisify } from 'util';
 import path from 'path';
 
-import { writeGeneratedSources } from './generate/sources';
+import { generateSources, writeGeneratedSources } from './generate/sources';
+import type { GenericOptions } from './build-generic';
+import { custom, erc1155, erc20, erc721, governor } from './api';
 
 test('result compiles', async t => {
   const generatedSourcesPath = path.join(hre.config.paths.sources, 'generated');
@@ -19,3 +20,34 @@ test('result compiles', async t => {
   await hre.run('compile');
   t.pass();
 });
+
+function isAccessControlRequired(opts: GenericOptions) {
+  switch(opts.kind) {
+    case 'ERC20':
+      return erc20.isAccessControlRequired(opts);
+    case 'ERC721':
+      return erc721.isAccessControlRequired(opts);
+    case 'ERC1155':
+      return erc1155.isAccessControlRequired(opts);
+    case 'Governor':
+      return governor.isAccessControlRequired(opts);
+    case 'Custom':
+      return custom.isAccessControlRequired(opts);
+    default:
+      throw new Error("No such kind");
+  }
+}
+
+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));
+      }
+    }
+  }
+});

package/src/utils/format-lines.ts

@@ -5,20 +5,25 @@ export type Lines = string | typeof whitespace | Lines[];
 const whitespace = Symbol('whitespace');
 
 export function formatLines(...lines: Lines[]): string {
-  return [...indentEach(0, lines)].join('\n') + '\n';
+  return formatLinesWithSpaces(4, ...lines);
+}
+
+export function formatLinesWithSpaces(spacesPerIndent: number, ...lines: Lines[]): string {
+  return [...indentEach(0, lines, spacesPerIndent)].join('\n') + '\n';
 }
 
 function* indentEach(
   indent: number,
   lines: Lines[],
+  spacesPerIndent: number,
 ): Generator<string | typeof whitespace> {
   for (const line of lines) {
     if (line === whitespace) {
       yield '';
     } else if (Array.isArray(line)) {
-      yield* indentEach(indent + 1, line);
+      yield* indentEach(indent + 1, line, spacesPerIndent);
     } else {
-      yield '    '.repeat(indent) + line;
+      yield ' '.repeat(indent * spacesPerIndent) + line;
     }
   }
 }