@openzeppelin/wizard 0.10.5 → 0.10.7

package/src/print.ts

@@ -75,15 +75,20 @@ function printVariableOrErrorDefinitionsWithoutComments(
   return withoutComments.map(v => v.code);
 }
 
+type LibraryDescription = {
+  nameAndVersion: string;
+  alwaysKeepOzPrefix?: boolean;
+};
+
 function printCompatibleLibraryVersions(contract: Contract, opts?: Options): string {
-  const libraries: string[] = [];
+  const libraryDescriptions: LibraryDescription[] = [];
   if (importsLibrary(contract, '@openzeppelin/contracts')) {
-    libraries.push(`OpenZeppelin Contracts ${compatibleContractsSemver}`);
+    libraryDescriptions.push({ nameAndVersion: `OpenZeppelin Contracts ${compatibleContractsSemver}` });
   }
   if (importsLibrary(contract, '@openzeppelin/community-contracts')) {
     try {
       const commit = getCommunityContractsGitCommit();
-      libraries.push(`Community Contracts commit ${commit}`);
+      libraryDescriptions.push({ nameAndVersion: `OpenZeppelin Community Contracts commit ${commit}` });
     } catch (e) {
       console.error(e);
     }
@@ -91,14 +96,35 @@ function printCompatibleLibraryVersions(contract: Contract, opts?: Options): str
   if (opts?.additionalCompatibleLibraries) {
     for (const library of opts.additionalCompatibleLibraries) {
       if (importsLibrary(contract, library.path)) {
-        libraries.push(`${library.name} ${library.version}`);
+        libraryDescriptions.push({
+          nameAndVersion: `${library.name} ${library.version}`,
+          alwaysKeepOzPrefix: library.alwaysKeepOzPrefix,
+        });
       }
     }
   }
 
-  if (libraries.length === 0) return '';
-  if (libraries.length === 1) return `// Compatible with ${libraries[0]}`;
-  return `// Compatible with ${libraries.slice(0, -1).join(', ')} and ${libraries.slice(-1)}`;
+  if (libraryDescriptions.length === 0) {
+    return '';
+  } else if (libraryDescriptions.length === 1) {
+    return `// Compatible with ${libraryDescriptions[0]!.nameAndVersion}`;
+  } else {
+    const OZ_PREFIX_WITH_SPACE = 'OpenZeppelin ';
+    if (libraryDescriptions[0]!.nameAndVersion.startsWith(OZ_PREFIX_WITH_SPACE)) {
+      for (let i = 1; i < libraryDescriptions.length; i++) {
+        if (
+          libraryDescriptions[i]!.nameAndVersion.startsWith(OZ_PREFIX_WITH_SPACE) &&
+          !libraryDescriptions[i]!.alwaysKeepOzPrefix
+        ) {
+          libraryDescriptions[i]!.nameAndVersion = libraryDescriptions[i]!.nameAndVersion.slice(
+            OZ_PREFIX_WITH_SPACE.length,
+          );
+        }
+      }
+    }
+    const librariesToPrint = libraryDescriptions.map(l => l.nameAndVersion);
+    return `// Compatible with ${librariesToPrint.slice(0, -1).join(', ')} and ${librariesToPrint.slice(-1)}`;
+  }
 }
 
 function printInheritance(contract: Contract, { transformName }: Helpers): [] | [string] {
@@ -334,30 +360,25 @@ function printNatspecTags(tags: NatspecTag[]): string[] {
 }
 
 function printImports(imports: ImportContract[], helpers: Helpers): string[] {
-  // Sort imports by name
-  imports.sort((a, b) => {
-    if (a.name < b.name) return -1;
-    if (a.name > b.name) return 1;
-    return 0;
-  });
-
-  const lines: string[] = [];
-  imports.map(p => {
-    const importContract = helpers.transformImport(p);
-    lines.push(`import {${importContract.name}} from "${importContract.path}";`);
-  });
+  const itemByPath = new Map<string, Set<string>>();
 
-  return lines;
+  for (const p of imports) {
+    const { name, path } = helpers.transformImport(p);
+    const _ = itemByPath.get(path)?.add(name) ?? itemByPath.set(path, new Set([name]));
+  }
+
+  return Array.from(itemByPath.keys())
+    .sort()
+    .map(path => `import {${Array.from(itemByPath.get(path)!).sort().join(', ')}} from "${path}";`);
 }
 
 function printLibraries(contract: Contract, { transformName }: Helpers): string[] {
   if (!contract.libraries || contract.libraries.length === 0) return [];
 
   return contract.libraries
-    .sort((a, b) => a.library.name.localeCompare(b.library.name))
-    .flatMap(lib =>
-      [...lib.usingFor]
-        .sort((a, b) => a.localeCompare(b))
-        .map(type => `using ${transformName(lib.library)} for ${type};`),
-    );
+    .sort((a, b) => a.library.name.localeCompare(b.library.name)) // Sort by import path
+    .map(lib => {
+      const sortedTypes = Array.from(lib.usingFor).sort((a, b) => a.localeCompare(b)); // Sort types
+      return `using ${transformName(lib.library)} for ${sortedTypes.join(', ')};`;
+    });
 }

package/src/stablecoin.ts

@@ -9,6 +9,7 @@ import {
   defaults as erc20defaults,
   withDefaults as withERC20Defaults,
   functions as erc20functions,
+  isAccessControlRequired as erc20isAccessControlRequired,
 } from './erc20';
 
 export type Limitations = 'allowlist' | 'blocklist';
@@ -41,7 +42,7 @@ export function printStablecoin(opts: StablecoinOptions = defaults): string {
 }
 
 export function isAccessControlRequired(opts: Partial<StablecoinOptions>): boolean {
-  return opts.mintable || opts.restrictions !== false || opts.freezable || opts.pausable || opts.upgradeable === 'uups';
+  return erc20isAccessControlRequired(opts) || !!opts.restrictions || !!opts.freezable;
 }
 
 export function buildStablecoin(opts: StablecoinOptions): Contract {

package/src/utils/convert-strings.ts

@@ -3,21 +3,32 @@ import { OptionsError } from '../error';
 export const UINT256_MAX = BigInt(2) ** BigInt(256) - BigInt(1);
 
 /**
- * Checks that a string is a valid `uint256` value and converts it to bigint.
+ * Checks that a string is a valid number, and convert to bigint.
  *
  * @param value The string value to check and convert.
  * @param field The field name to use in the error message if the value is invalid.
- * @throws OptionsError if the value is not a valid number or is greater than the maximum value for `uint256`.
+ * @throws OptionsError if the value is not a valid number.
  * @returns The validated value as a bigint.
  */
-export function toUint256(value: string, field: string): bigint {
+export function toBigInt(value: string, field: string): bigint {
   const isValidNumber = /^\d+$/.test(value);
   if (!isValidNumber) {
     throw new OptionsError({
       [field]: 'Not a valid number',
     });
   }
-  const numValue = BigInt(value);
+  return BigInt(value);
+}
+
+/**
+ * Checks that a bigint value fits within `uint256`.
+ *
+ * @param numValue The value to check.
+ * @param field The field name to use in the error if the value is invalid.
+ * @throws OptionsError if the value is greater than the maximum value for `uint256`.
+ * @returns The value as a bigint.
+ */
+export function validateUint256(numValue: bigint, field: string): bigint {
   if (numValue > UINT256_MAX) {
     throw new OptionsError({
       [field]: 'Value is greater than uint256 max value',
@@ -25,3 +36,16 @@ export function toUint256(value: string, field: string): bigint {
   }
   return numValue;
 }
+
+/**
+ * Checks that a string is a valid number, and fits within `uint256`.
+ * Convenience function that calls `toBigInt` and `validateUint256`.
+ *
+ * @param value The value to check.
+ * @param field The field name to use in the error if the value is invalid.
+ * @throws OptionsError if the value is not a valid number or is greater than the maximum value for `uint256`.
+ * @returns The value as a bigint.
+ */
+export function toUint256(value: string, field: string): bigint {
+  return validateUint256(toBigInt(value, field), field);
+}

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.5.0';
+export const compatibleContractsSemver = '^5.6.0';