@openzeppelin/wizard 0.1.0 → 0.2.0

package/src/api.ts

@@ -1,8 +1,9 @@
 import type { CommonOptions } from './common-options';
-import { printERC20, defaults as erc20defaults, ERC20Options } from './erc20';
-import { printERC721, defaults as erc721defaults, ERC721Options } from './erc721';
-import { printERC1155, defaults as erc1155defaults, ERC1155Options } from './erc1155';
-import { printGovernor, defaults as governorDefaults, GovernorOptions } from './governor';
+import { printERC20, defaults as erc20defaults, isAccessControlRequired as erc20IsAccessControlRequired, ERC20Options } from './erc20';
+import { printERC721, defaults as erc721defaults, isAccessControlRequired as erc721IsAccessControlRequired, ERC721Options } from './erc721';
+import { printERC1155, defaults as erc1155defaults, isAccessControlRequired as erc1155IsAccessControlRequired, ERC1155Options } from './erc1155';
+import { printGovernor, defaults as governorDefaults, isAccessControlRequired as governorIsAccessControlRequired, GovernorOptions } from './governor';
+import { printCustom, defaults as customDefaults, isAccessControlRequired as customIsAccessControlRequired, CustomOptions } from './custom';
 
 export interface WizardContractAPI<Options extends CommonOptions> {
   /**
@@ -14,26 +15,42 @@ export interface WizardContractAPI<Options extends CommonOptions> {
    * The default options that are used for `print`.
    */
   defaults: Required<Options>;
+
+  /**
+   * Whether any of the provided options require access control to be enabled. If this returns `true`, then calling `print` with the 
+   * same options would cause the `access` option to default to `'ownable'` if it was `undefined` or `false`. 
+   */
+  isAccessControlRequired: (opts: Partial<Options>) => boolean,
 }
 
 export type ERC20 = WizardContractAPI<ERC20Options>;
 export type ERC721 = WizardContractAPI<ERC721Options>;
 export type ERC1155 = WizardContractAPI<ERC1155Options>;
 export type Governor = WizardContractAPI<GovernorOptions>;
+export type Custom = WizardContractAPI<CustomOptions>;
 
 export const erc20: ERC20 = {
   print: printERC20,
-  defaults: erc20defaults
+  defaults: erc20defaults,
+  isAccessControlRequired: erc20IsAccessControlRequired
 }
 export const erc721: ERC721 = {
   print: printERC721,
-  defaults: erc721defaults
+  defaults: erc721defaults,
+  isAccessControlRequired: erc721IsAccessControlRequired
 }
 export const erc1155: ERC1155 = {
   print: printERC1155,
-  defaults: erc1155defaults
+  defaults: erc1155defaults,
+  isAccessControlRequired: erc1155IsAccessControlRequired
 }
 export const governor: Governor = {
   print: printGovernor,
-  defaults: governorDefaults
+  defaults: governorDefaults,
+  isAccessControlRequired: governorIsAccessControlRequired
+}
+export const custom: Custom = {
+  print: printCustom,
+  defaults: customDefaults,
+  isAccessControlRequired: customIsAccessControlRequired
 }

package/src/build-generic.ts

@@ -1,3 +1,4 @@
+import { CustomOptions, buildCustom } from './custom';
 import { ERC20Options, buildERC20 } from './erc20';
 import { ERC721Options, buildERC721 } from './erc721';
 import { ERC1155Options, buildERC1155 } from './erc1155';
@@ -8,6 +9,7 @@ export interface KindedOptions {
   ERC721:   { kind: 'ERC721' }   & ERC721Options;
   ERC1155:  { kind: 'ERC1155' }  & ERC1155Options;
   Governor: { kind: 'Governor' } & GovernorOptions;
+  Custom:  { kind: 'Custom' }  & CustomOptions;
 }
 
 export type GenericOptions = KindedOptions[keyof KindedOptions];
@@ -26,6 +28,9 @@ export function buildGeneric(opts: GenericOptions) {
     case 'Governor':
       return buildGovernor(opts);
 
+    case 'Custom':
+      return buildCustom(opts);
+
     default:
       const _: never = opts;
       throw new Error('Unknown ERC');

package/src/common-options.ts

@@ -4,7 +4,7 @@ import { defaults as infoDefaults } from "./set-info";
 import type { Upgradeable } from "./set-upgradeable";
 
 export const defaults: Required<CommonOptions> = {
-  access: 'ownable',
+  access: false,
   upgradeable: false,
   info: infoDefaults,
 } as const;
@@ -17,7 +17,7 @@ export interface CommonOptions {
 
 export function withCommonDefaults(opts: CommonOptions): Required<CommonOptions> {
   return {
-    access: opts.access ?? 'ownable',
+    access: opts.access ?? false,
     upgradeable: opts.upgradeable ?? false,
     info: opts.info ?? {},
   };

package/src/custom.ts

@@ -0,0 +1,55 @@
+import { Contract, ContractBuilder } from './contract';
+import { CommonOptions, withCommonDefaults, defaults as commonDefaults } from './common-options';
+import { setUpgradeable } from './set-upgradeable';
+import { setInfo } from './set-info';
+import { setAccessControl } from './set-access-control';
+import { addPausable } from './add-pausable';
+import { printContract } from './print';
+
+export interface CustomOptions extends CommonOptions {
+  name: string;
+  pausable?: boolean;
+}
+
+export const defaults: Required<CustomOptions> = {
+  name: 'MyContract',
+  pausable: false,
+  access: commonDefaults.access,
+  upgradeable: commonDefaults.upgradeable,
+  info: commonDefaults.info,
+} as const;
+
+function withDefaults(opts: CustomOptions): Required<CustomOptions> {
+  return {
+    ...opts,
+    ...withCommonDefaults(opts),
+    pausable: opts.pausable ?? defaults.pausable,
+  };
+}
+
+export function printCustom(opts: CustomOptions = defaults): string {
+  return printContract(buildCustom(opts));
+}
+
+export function isAccessControlRequired(opts: Partial<CustomOptions>): boolean {
+  return opts.pausable || opts.upgradeable === 'uups';
+}
+
+export function buildCustom(opts: CustomOptions): Contract {
+  const allOpts = withDefaults(opts);
+
+  const c = new ContractBuilder(allOpts.name);
+
+  const { access, upgradeable, info } = allOpts;
+
+  if (allOpts.pausable) {
+    addPausable(c, access, []);
+  }
+
+  setAccessControl(c, access);
+  setUpgradeable(c, upgradeable, access);
+  setInfo(c, info);
+
+  return c;
+}
+