@openzeppelin/wizard 0.10.3 → 0.10.5

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/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/governor.ts

@@ -40,6 +40,8 @@ export function printGovernor(opts: GovernorOptions = defaults): string {
   return printContract(buildGovernor(opts));
 }
 
+export type QuorumMode = 'percent' | 'absolute';
+
 export interface GovernorOptions extends CommonOptions {
   name: string;
   delay: string;
@@ -47,7 +49,7 @@ export interface GovernorOptions extends CommonOptions {
   blockTime?: number;
   proposalThreshold?: string;
   decimals?: number;
-  quorumMode?: 'percent' | 'absolute';
+  quorumMode?: QuorumMode;
   quorumPercent?: number;
   quorumAbsolute?: string;
   votes?: VotesOptions;

package/src/index.ts

@@ -1,7 +1,9 @@
 export type { GenericOptions, KindedOptions } from './build-generic';
 export { buildGeneric } from './build-generic';
 
-export type { Contract } from './contract';
+export { generateAlternatives } from './generate/alternatives';
+
+export type { Contract, BaseFunction, Value, ReferencedContract } from './contract';
 export { ContractBuilder } from './contract';
 
 export { printContract } from './print';
@@ -11,7 +13,9 @@ export type { Upgradeable } from './set-upgradeable';
 export type { Info } from './set-info';
 
 export { premintPattern, chainIdPattern } from './erc20';
-export { defaults as infoDefaults } from './set-info';
+export { defaults as infoDefaults, infoOptions, setInfo } from './set-info';
+export { accessOptions, setAccessControl, requireAccessControl } from './set-access-control';
+export { addPausable } from './add-pausable';
 
 export type { OptionsErrorMessages } from './error';
 export { OptionsError } from './error';
@@ -20,8 +24,15 @@ 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 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';

package/src/options.ts

@@ -27,6 +27,10 @@ export function upgradeableImport(p: ImportContract): ImportContract {
 
 export interface Options {
   transformImport?: (parent: ImportContract) => ImportContract;
+  /**
+   * Add additional libraries to the compatibility banner printed at the top of the contract.
+   */
+  additionalCompatibleLibraries?: { name: string; path: string; version: string }[];
 }
 
 export interface Helpers extends Required<Options> {
@@ -45,5 +49,6 @@ export function withHelpers(contract: Contract, opts: Options = {}): Helpers {
       const p2 = contractUpgradeable && inferTranspiled(p1) ? upgradeableImport(p1) : p1;
       return opts.transformImport?.(p2) ?? p2;
     },
+    additionalCompatibleLibraries: opts.additionalCompatibleLibraries ?? [],
   };
 }

package/src/print.ts

@@ -19,7 +19,7 @@ import SOLIDITY_VERSION from './solidity-version.json';
 import { inferTranspiled } from './infer-transpiled';
 import { compatibleContractsSemver } from './utils/version';
 import { stringifyUnicodeSafe } from './utils/sanitize';
-import { importsCommunityContracts } from './utils/imports-libraries';
+import { importsLibrary } from './utils/imports-libraries';
 import { getCommunityContractsGitCommit } from './utils/community-contracts-git-commit';
 
 export function printContract(contract: Contract, opts?: Options): string {
@@ -32,17 +32,19 @@ export function printContract(contract: Contract, opts?: Options): string {
     ...spaceBetween(
       [
         `// SPDX-License-Identifier: ${contract.license}`,
-        printCompatibleLibraryVersions(contract),
+        printCompatibleLibraryVersions(contract, opts),
         `pragma solidity ^${SOLIDITY_VERSION};`,
       ],
 
       printImports(contract.imports, helpers),
 
       [
+        ...printTopLevelComments(contract.topLevelComments, contract.natspecTags.length > 0),
         ...printNatspecTags(contract.natspecTags),
         [`contract ${contract.name}`, ...printInheritance(contract, helpers), '{'].join(' '),
 
         spaceBetween(
+          printLibraries(contract, helpers),
           ...structs,
           printVariableOrErrorDefinitionsWithComments(contract.variableOrErrorDefinitions),
           printVariableOrErrorDefinitionsWithoutComments(contract.variableOrErrorDefinitions),
@@ -73,25 +75,38 @@ function printVariableOrErrorDefinitionsWithoutComments(
   return withoutComments.map(v => v.code);
 }
 
-function printCompatibleLibraryVersions(contract: Contract): string {
-  let result = `// Compatible with OpenZeppelin Contracts ${compatibleContractsSemver}`;
-  if (importsCommunityContracts(contract)) {
+function printCompatibleLibraryVersions(contract: Contract, opts?: Options): string {
+  const libraries: string[] = [];
+  if (importsLibrary(contract, '@openzeppelin/contracts')) {
+    libraries.push(`OpenZeppelin Contracts ${compatibleContractsSemver}`);
+  }
+  if (importsLibrary(contract, '@openzeppelin/community-contracts')) {
     try {
       const commit = getCommunityContractsGitCommit();
-      result += ` and Community Contracts commit ${commit}`;
+      libraries.push(`Community Contracts commit ${commit}`);
     } catch (e) {
       console.error(e);
     }
   }
-  return result;
+  if (opts?.additionalCompatibleLibraries) {
+    for (const library of opts.additionalCompatibleLibraries) {
+      if (importsLibrary(contract, library.path)) {
+        libraries.push(`${library.name} ${library.version}`);
+      }
+    }
+  }
+
+  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)}`;
 }
 
 function printInheritance(contract: Contract, { transformName }: Helpers): [] | [string] {
-  if (contract.parents.length > 0) {
-    return ['is ' + contract.parents.map(p => transformName(p.contract)).join(', ')];
-  } else {
-    return [];
+  const visibleParents = contract.parents.filter(p => !p.constructionOnly);
+  if (visibleParents.length > 0) {
+    return ['is ' + visibleParents.map(p => transformName(p.contract)).join(', ')];
   }
+  return [];
 }
 
 function printConstructor(contract: Contract, helpers: Helpers): Lines[] {
@@ -308,6 +323,12 @@ function printArgument(arg: FunctionArgument, { transformName }: Helpers): strin
   return [type, arg.name].join(' ');
 }
 
+function printTopLevelComments(comments: string[], withExtraBlankLine: boolean = false): string[] {
+  const lines = comments.map(comment => `// ${comment}`);
+  if (comments.length > 0 && withExtraBlankLine) lines.push('//');
+  return lines;
+}
+
 function printNatspecTags(tags: NatspecTag[]): string[] {
   return tags.map(({ key, value }) => `/// ${key} ${value}`);
 }
@@ -328,3 +349,15 @@ function printImports(imports: ImportContract[], helpers: Helpers): string[] {
 
   return lines;
 }
+
+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};`),
+    );
+}

package/src/stablecoin.ts

@@ -11,6 +11,8 @@ import {
   functions as erc20functions,
 } from './erc20';
 
+export type Limitations = 'allowlist' | 'blocklist';
+
 export interface StablecoinOptions extends ERC20Options {
   restrictions?: false | 'allowlist' | 'blocklist';
   freezable?: boolean;

package/src/utils/imports-libraries.ts

@@ -1,5 +1,5 @@
 import type { Contract } from '../contract';
 
-export function importsCommunityContracts(contract: Contract) {
-  return contract.imports.some(i => i.path.startsWith('@openzeppelin/community-contracts/'));
+export function importsLibrary(contract: Contract, library: string) {
+  return contract.imports.some(i => i.path.startsWith(library));
 }

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