@openzeppelin/wizard 0.10.4 → 0.10.6

package/src/environments/hardhat/polkadot/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "hardhat-sample",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "hardhat test"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@openzeppelin/contracts": "^5.5.0",
+    "@parity/hardhat-polkadot": "^0.2.7",
+    "@nomicfoundation/hardhat-toolbox": "^6.1.0",
+    "hardhat": "^2.22.0"
+  }
+}

package/src/erc20.ts

@@ -173,7 +173,7 @@ export function isValidChainId(str: string): boolean {
   return chainIdPattern.test(str);
 }
 
-function scaleByPowerOfTen(base: bigint, exponent: number): bigint {
+export function scaleByPowerOfTen(base: bigint, exponent: number): bigint {
   if (exponent < 0) {
     return base / BigInt(10) ** BigInt(-exponent);
   } else {
@@ -181,55 +181,74 @@ function scaleByPowerOfTen(base: bigint, exponent: number): bigint {
   }
 }
 
+export interface PremintCalculation {
+  units: string;
+  exp: string;
+  decimalPlace: number;
+}
+
+export function calculatePremint(amount: string): PremintCalculation | undefined {
+  const m = amount.match(premintPattern);
+  if (!m) {
+    throw new OptionsError({
+      premint: 'Not a valid number',
+    });
+  }
+
+  const integer = m[1]?.replace(/^0+/, '') ?? '';
+  const decimals = m[2]?.replace(/0+$/, '') ?? '';
+  const exponent = Number(m[3] ?? 0);
+
+  if (Number(integer + decimals) > 0) {
+    const decimalPlace = decimals.length - exponent;
+    const zeroes = new Array(Math.max(0, -decimalPlace)).fill('0').join('');
+    const units = integer + decimals + zeroes;
+    const exp = decimalPlace <= 0 ? 'decimals()' : `(decimals() - ${decimalPlace})`;
+
+    return { units, exp, decimalPlace };
+  } else {
+    return undefined;
+  }
+}
+
 function addPremint(
   c: ContractBuilder,
   amount: string,
   premintChainId: string,
   crossChainBridging: CrossChainBridging,
 ) {
-  const m = amount.match(premintPattern);
-  if (m) {
-    const integer = m[1]?.replace(/^0+/, '') ?? '';
-    const decimals = m[2]?.replace(/0+$/, '') ?? '';
-    const exponent = Number(m[3] ?? 0);
-
-    if (Number(integer + decimals) > 0) {
-      const decimalPlace = decimals.length - exponent;
-      const zeroes = new Array(Math.max(0, -decimalPlace)).fill('0').join('');
-      const units = integer + decimals + zeroes;
-      const exp = decimalPlace <= 0 ? 'decimals()' : `(decimals() - ${decimalPlace})`;
+  const premintCalculation = calculatePremint(amount);
+  if (premintCalculation === undefined) {
+    return;
+  }
 
-      const validatedBaseUnits = toUint256(units, 'premint');
-      checkPotentialPremintOverflow(validatedBaseUnits, decimalPlace);
+  const { units, exp, decimalPlace } = premintCalculation;
 
-      c.addConstructorArgument({ type: 'address', name: 'recipient' });
+  const validatedBaseUnits = toUint256(units, 'premint');
+  checkPotentialPremintOverflow(validatedBaseUnits, decimalPlace);
 
-      const mintLine = `_mint(recipient, ${units} * 10 ** ${exp});`;
+  c.addConstructorArgument({ type: 'address', name: 'recipient' });
 
-      if (crossChainBridging) {
-        if (premintChainId === '') {
-          throw new OptionsError({
-            premintChainId: 'Chain ID is required when using Premint with Cross-Chain Bridging',
-          });
-        }
+  const mintLine = `_mint(recipient, ${units} * 10 ** ${exp});`;
 
-        if (!isValidChainId(premintChainId)) {
-          throw new OptionsError({
-            premintChainId: 'Not a valid chain ID',
-          });
-        }
+  if (crossChainBridging) {
+    if (premintChainId === '') {
+      throw new OptionsError({
+        premintChainId: 'Chain ID is required when using Premint with Cross-Chain Bridging',
+      });
+    }
 
-        c.addConstructorCode(`if (block.chainid == ${premintChainId}) {`);
-        c.addConstructorCode(`    ${mintLine}`);
-        c.addConstructorCode(`}`);
-      } else {
-        c.addConstructorCode(mintLine);
-      }
+    if (!isValidChainId(premintChainId)) {
+      throw new OptionsError({
+        premintChainId: 'Not a valid chain ID',
+      });
     }
+
+    c.addConstructorCode(`if (block.chainid == ${premintChainId}) {`);
+    c.addConstructorCode(`    ${mintLine}`);
+    c.addConstructorCode(`}`);
   } else {
-    throw new OptionsError({
-      premint: 'Not a valid number',
-    });
+    c.addConstructorCode(mintLine);
   }
 }
 

package/src/get-versioned-remappings.ts

@@ -1,5 +1,5 @@
 import type { CommonOptions } from './common-options';
-import contractsVersion from '../openzeppelin-contracts-version';
+import contractsVersion from '../openzeppelin-contracts-version.json';
 
 export function getVersionedRemappings(opts?: CommonOptions): string[] {
   const remappings = [`@openzeppelin/contracts/=@openzeppelin/contracts@${contractsVersion.version}/`];

package/src/index.ts

@@ -1,21 +1,37 @@
+// ===== Public API =====
+
+export { erc20, erc721, erc1155, stablecoin, realWorldAsset, account, governor, custom } from './api';
+export type { WizardContractAPI, AccessControlAPI } from './api';
+
+export type { ERC20Options } from './erc20';
+export type { ERC721Options } from './erc721';
+export type { ERC1155Options } from './erc1155';
+export type { StablecoinOptions } from './stablecoin';
+export type { AccountOptions } from './account';
+export type { GovernorOptions } from './governor';
+export type { CustomOptions } from './custom';
+
+// ===== Internal API - Intended for use by other Wizard packages only =====
+
 export type { GenericOptions, KindedOptions } from './build-generic';
 export { buildGeneric } from './build-generic';
 
 export { generateAlternatives } from './generate/alternatives';
 
-export type { Contract, BaseFunction, Value, ReferencedContract } from './contract';
+export type { Contract, BaseFunction, Value, ReferencedContract, FunctionArgument } from './contract';
 export { ContractBuilder } from './contract';
 
 export { printContract } from './print';
 
 export type { Access } from './set-access-control';
+export { accessOptions, setAccessControl, requireAccessControl } from './set-access-control';
+export { addPausable } from './add-pausable';
 export type { Upgradeable } from './set-upgradeable';
 export type { Info } from './set-info';
 
 export { premintPattern, chainIdPattern } from './erc20';
-export { defaults as infoDefaults, infoOptions, setInfo } from './set-info';
-export { accessOptions, setAccessControl, requireAccessControl } from './set-access-control';
-export { addPausable } from './add-pausable';
+export { defaults as infoDefaults, setInfo, infoOptions } from './set-info';
+export { supportsInterface } from './common-functions';
 
 export type { OptionsErrorMessages } from './error';
 export { OptionsError } from './error';
@@ -23,21 +39,17 @@ export { OptionsError } from './error';
 export type { Kind } from './kind';
 export { sanitizeKind } from './kind';
 
-export { erc20, erc721, erc1155, stablecoin, realWorldAsset, account, governor, custom } from './api';
-export type { WizardContractAPI, AccessControlAPI } from './api';
-
 export { compatibleContractsSemver } from './utils/version';
-export { findCover } from './utils/find-cover';
-export { defineFunctions } from './utils/define-functions';
 
+export { defineFunctions } from './utils/define-functions';
 export type { CommonOptions } from './common-options';
 export { withCommonDefaults, defaults as commonDefaults } from './common-options';
-export { supportsInterface } from './common-functions';
-
-export type { ERC20Options } from './erc20';
-export type { ERC721Options } from './erc721';
-export type { ERC1155Options } from './erc1155';
-export type { StablecoinOptions } from './stablecoin';
-export type { AccountOptions } from './account';
-export type { GovernorOptions } from './governor';
-export type { CustomOptions } from './custom';
+export type { ClockMode } from './set-clock-mode';
+export { clockModeDefault, setClockMode, clockModeOptions } from './set-clock-mode';
+export { toBigInt } from './utils/convert-strings';
+export type { Options } from './options';
+export type { Lines } from './utils/format-lines';
+export { formatLinesWithSpaces, spaceBetween } from './utils/format-lines';
+export { findCover } from './utils/find-cover';
+export type { PremintCalculation } from './erc20';
+export { calculatePremint as calculateERC20Premint, scaleByPowerOfTen } from './erc20';

package/src/options.ts

@@ -29,8 +29,10 @@ export interface Options {
   transformImport?: (parent: ImportContract) => ImportContract;
   /**
    * Add additional libraries to the compatibility banner printed at the top of the contract.
+   *
+   * If `alwaysKeepOzPrefix` is true, the library name will always keep the "OpenZeppelin " prefix, even if there are multiple libraries from OpenZeppelin being imported.
    */
-  additionalCompatibleLibraries?: { name: string; path: string; version: string }[];
+  additionalCompatibleLibraries?: { name: string; path: string; version: string; alwaysKeepOzPrefix?: boolean }[];
 }
 
 export interface Helpers extends Required<Options> {

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/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/zip-hardhat-polkadot.ts

@@ -0,0 +1,86 @@
+import type JSZip from 'jszip';
+import type { Contract } from './contract';
+import { HardhatZipGenerator } from './zip-hardhat';
+import type { GenericOptions } from './build-generic';
+import SOLIDITY_VERSION from './solidity-version.json';
+
+class HardhatPolkadotZipGenerator extends HardhatZipGenerator {
+  protected getAdditionalHardhatImports(): string[] {
+    return ['@parity/hardhat-polkadot'];
+  }
+
+  protected getHardhatConfigJsonString(): string {
+    return `\
+{
+  solidity: {
+    version: "${SOLIDITY_VERSION}",
+    settings: {
+      evmVersion: 'cancun',
+      optimizer: {
+        enabled: true,
+      },
+    },
+  },
+  resolc: {
+    compilerSource: 'npm',
+  },
+  networks: {
+    hardhat: {
+      polkavm: true,
+      nodeConfig: {
+        nodeBinaryPath: 'INSERT_PATH_TO_REVIVE_DEV_NODE',
+        rpcPort: 8000,
+        dev: true,
+      },
+      adapterConfig: {
+        adapterBinaryPath: 'INSERT_PATH_TO_ETH_RPC_ADAPTER',
+        dev: true,
+      },
+    },
+  },
+}`;
+  }
+
+  protected async getPackageJson(c: Contract): Promise<unknown> {
+    const { default: packageJson } = await import('./environments/hardhat/polkadot/package.json');
+    packageJson.license = c.license;
+    return packageJson;
+  }
+
+  protected async getPackageLock(c: Contract): Promise<unknown> {
+    const { default: packageLock } = await import('./environments/hardhat/polkadot/package-lock.json');
+    packageLock.packages[''].license = c.license;
+    return packageLock;
+  }
+
+  protected getReadmePrerequisitesSection(): string {
+    return `\
+## Prerequisites
+
+Ensure you have the following installed:
+- [Node.js 22.5+](https://nodejs.org/en/download/)
+- npm 10.9.0+
+
+`;
+  }
+
+  protected getReadmeTestingEnvironmentSetupSection(): string {
+    return `\
+## Setting up a testing environment
+
+Follow the steps in [Polkadot's documentation](https://docs.polkadot.com/smart-contracts/dev-environments/local-dev-node/) to set up a local development node and replace the placeholder values \`INSERT_PATH_TO_REVIVE_DEV_NODE\` and \`INSERT_PATH_TO_ETH_RPC_ADAPTER\` in \`hardhat.config.ts\`.
+
+`;
+  }
+
+  protected getGitIgnoreHardhatIgnition(): string {
+    return `
+# Hardhat Ignition default folder for deployments against a local Polkadot Revive Dev node
+ignition/deployments/chain-420420420
+    `;
+  }
+}
+
+export async function zipHardhatPolkadot(c: Contract, opts?: GenericOptions): Promise<JSZip> {
+  return new HardhatPolkadotZipGenerator().zipHardhat(c, opts);
+}