@openzeppelin/wizard 0.10.4 → 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/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);
+}

package/src/zip-hardhat.ts

@@ -1,72 +1,31 @@
 import JSZip from 'jszip';
 import type { GenericOptions } from './build-generic';
-import type { Contract } from './contract';
+import type { Contract, FunctionArgument } from './contract';
 import { printContract } from './print';
 import SOLIDITY_VERSION from './solidity-version.json';
 import type { Lines } from './utils/format-lines';
 import { formatLinesWithSpaces, spaceBetween } from './utils/format-lines';
 
-const hardhatConfig = (upgradeable: boolean) => `\
-import { HardhatUserConfig } from "hardhat/config";
-import "@nomicfoundation/hardhat-toolbox";
-${upgradeable ? `import "@openzeppelin/hardhat-upgrades";` : ''}
-
-const config: HardhatUserConfig = {
-  solidity: {
-    version: "${SOLIDITY_VERSION}",
-    settings: {
-      evmVersion: 'cancun',
-      optimizer: {
-        enabled: true,
-      },
-    },
-  },
-};
+class TestGenerator {
+  constructor(private parent: HardhatZipGenerator) {}
 
-export default config;
-`;
-
-const tsConfig = `\
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true
+  getContent(c: Contract, opts?: GenericOptions): string {
+    return formatLinesWithSpaces(2, ...spaceBetween(this.getImports(c), this.getTestCase(c, opts)));
   }
-}
-`;
 
-const gitIgnore = `\
-node_modules
-.env
-coverage
-coverage.json
-typechain
-typechain-types
-
-# Hardhat files
-cache
-artifacts
-`;
-
-const test = (c: Contract, opts?: GenericOptions) => {
-  return formatLinesWithSpaces(2, ...spaceBetween(getImports(c), getTestCase(c)));
-
-  function getTestCase(c: Contract) {
-    const args = getAddressArgs(c);
+  private getTestCase(c: Contract, opts?: GenericOptions): Lines[] {
     return [
       `describe("${c.name}", function () {`,
       [
         'it("Test contract", async function () {',
         spaceBetween(
           [`const ContractFactory = await ethers.getContractFactory("${c.name}");`],
-          getAddressVariables(args),
-          [`const instance = await ${getDeploymentCall(c, args)};`, 'await instance.waitForDeployment();'],
-          getExpects(),
+          this.declareVariables(c.constructorArgs),
+          this.getDeployLines(
+            c,
+            c.constructorArgs.map(a => a.name),
+          ),
+          this.getExpects(opts),
         ),
         '});',
       ],
@@ -74,25 +33,25 @@ const test = (c: Contract, opts?: GenericOptions) => {
     ];
   }
 
-  function getImports(c: Contract) {
-    return ['import { expect } from "chai";', `import { ${getHardhatPlugins(c).join(', ')} } from "hardhat";`];
+  private getImports(c: Contract): Lines[] {
+    return [
+      'import { expect } from "chai";',
+      `import { ${this.parent.getHardhatPlugins(c).join(', ')} } from "hardhat";`,
+    ];
   }
 
-  function getExpects(): Lines[] {
+  private getExpects(opts?: GenericOptions): Lines[] {
     if (opts !== undefined) {
       switch (opts.kind) {
         case 'ERC20':
         case 'ERC721':
           return [`expect(await instance.name()).to.equal("${opts.name}");`];
-
         case 'ERC1155':
           return [`expect(await instance.uri(0)).to.equal("${opts.uri}");`];
-
         case 'Account':
         case 'Governor':
         case 'Custom':
           break;
-
         default:
           throw new Error('Unknown ERC');
       }
@@ -100,46 +59,133 @@ const test = (c: Contract, opts?: GenericOptions) => {
     return [];
   }
 
-  function getAddressVariables(args: string[]): Lines[] {
-    const vars = [];
-    for (let i = 0; i < args.length; i++) {
-      vars.push(`const ${args[i]} = (await ethers.getSigners())[${i}].address;`);
-    }
-    return vars;
+  private declareVariables(args: FunctionArgument[]): Lines[] {
+    return args.flatMap((arg, i) => {
+      if (arg.type === 'address') {
+        return [`const ${arg.name} = (await ethers.getSigners())[${i}].address;`];
+      } else {
+        return [`// TODO: Set the following constructor argument`, `// const ${arg.name} = ...;`];
+      }
+    });
   }
-};
 
-function getAddressArgs(c: Contract): string[] {
-  const args = [];
-  for (const constructorArg of c.constructorArgs) {
-    if (constructorArg.type === 'address') {
-      args.push(constructorArg.name);
+  private getDeployLines(c: Contract, argNames: string[]): Lines[] {
+    if (c.constructorArgs.some(a => a.type !== 'address')) {
+      return [
+        `// TODO: Uncomment the below when the missing constructor arguments are set above`,
+        `// const instance = await ${this.parent.getDeploymentCall(c, argNames)};`,
+        `// await instance.waitForDeployment();`,
+      ];
+    } else {
+      return [
+        `const instance = await ${this.parent.getDeploymentCall(c, argNames)};`,
+        'await instance.waitForDeployment();',
+      ];
     }
   }
-  return args;
 }
 
-function getDeploymentCall(c: Contract, args: string[]): string {
-  // TODO: remove that selector when the upgrades plugin supports @custom:oz-upgrades-unsafe-allow-reachable
-  const unsafeAllowConstructor = c.parents.find(p => ['EIP712'].includes(p.contract.name)) !== undefined;
+export class HardhatZipGenerator {
+  protected getAdditionalHardhatImports(): string[] {
+    return [];
+  }
+
+  protected getHardhatConfigJsonString(): string {
+    return `\
+{
+  solidity: {
+    version: "${SOLIDITY_VERSION}",
+    settings: {
+      evmVersion: 'cancun',
+      optimizer: {
+        enabled: true,
+      },
+    },
+  },
+}`;
+  }
+
+  protected getHardhatConfig(upgradeable: boolean): string {
+    const additionalImports = this.getAdditionalHardhatImports();
+    const importsSection =
+      additionalImports.length > 0 ? additionalImports.map(imp => `import "${imp}";`).join('\n') + '\n' : '';
 
-  return !c.upgradeable
-    ? `ContractFactory.deploy(${args.join(', ')})`
-    : unsafeAllowConstructor
-      ? `upgrades.deployProxy(ContractFactory, [${args.join(', ')}], { unsafeAllow: 'constructor' })`
-      : `upgrades.deployProxy(ContractFactory, [${args.join(', ')}])`;
+    return `\
+import { HardhatUserConfig } from "hardhat/config";
+import "@nomicfoundation/hardhat-toolbox";
+${importsSection}${upgradeable ? `import "@openzeppelin/hardhat-upgrades";` : ''}
+
+const config: HardhatUserConfig = ${this.getHardhatConfigJsonString()};
+
+export default config;
+`;
+  }
+
+  protected getTsConfig(): string {
+    return `\
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  }
 }
+`;
+  }
 
-const script = (c: Contract) => {
-  const args = getAddressArgs(c);
-  return `\
-import { ${getHardhatPlugins(c).join(', ')} } from "hardhat";
+  protected getGitIgnoreHardhatIgnition(): string {
+    return `
+# Hardhat Ignition default folder for deployments against a local node
+ignition/deployments/chain-31337
+`;
+  }
+
+  protected getGitIgnore(): string {
+    return `\
+node_modules
+.env
+coverage
+coverage.json
+typechain
+typechain-types
+
+# Hardhat files
+cache
+artifacts
+${this.getGitIgnoreHardhatIgnition()}`;
+  }
+
+  protected getTest(c: Contract, opts?: GenericOptions): string {
+    return new TestGenerator(this).getContent(c, opts);
+  }
+
+  public getDeploymentCall(c: Contract, args: string[]): string {
+    // TODO: remove that selector when the upgrades plugin supports @custom:oz-upgrades-unsafe-allow-reachable
+    const unsafeAllowConstructor = c.parents.find(p => ['EIP712'].includes(p.contract.name)) !== undefined;
+
+    return !c.upgradeable
+      ? `ContractFactory.deploy(${args.join(', ')})`
+      : unsafeAllowConstructor
+        ? `upgrades.deployProxy(ContractFactory, [${args.join(', ')}], { unsafeAllow: ['constructor'] })`
+        : `upgrades.deployProxy(ContractFactory, [${args.join(', ')}])`;
+  }
+
+  protected getScript(c: Contract): string {
+    return `\
+import { ${this.getHardhatPlugins(c).join(', ')} } from "hardhat";
 
 async function main() {
   const ContractFactory = await ethers.getContractFactory("${c.name}");
 
-  ${args.length > 0 ? '// TODO: Set addresses for the contract arguments below' : ''}
-  const instance = await ${getDeploymentCall(c, args)};
+  ${c.constructorArgs.length > 0 ? '// TODO: Set values for the constructor arguments below' : ''}
+  const instance = await ${this.getDeploymentCall(
+    c,
+    c.constructorArgs.map(a => a.name),
+  )};
   await instance.waitForDeployment();
 
   console.log(\`${c.upgradeable ? 'Proxy' : 'Contract'} deployed to \${await instance.getAddress()}\`);
@@ -152,38 +198,47 @@ main().catch((error) => {
   process.exitCode = 1;
 });
 `;
-};
-
-const lowerFirstCharacter = (str: string) => str.charAt(0).toLowerCase() + str.slice(1);
+  }
 
-const ignitionModule = (c: Contract) => {
-  const deployArguments = getAddressArgs(c);
-  const contractVariableName = lowerFirstCharacter(c.name);
+  private lowerFirstCharacter(str: string): string {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+  }
 
-  return `import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
+  protected getIgnitionModule(c: Contract): string {
+    const contractVariableName = this.lowerFirstCharacter(c.name);
+    return `import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
 
 export default buildModule("${c.name}Module", (m) => {
 
-  ${deployArguments.length > 0 ? '// TODO: Set addresses for the contract arguments below' : ''}
-  const ${contractVariableName} = m.contract("${c.name}", [${deployArguments.join(', ')}]);
+  ${c.constructorArgs.length > 0 ? '// TODO: Set values for the constructor arguments below' : ''}
+  const ${contractVariableName} = m.contract("${c.name}", [${c.constructorArgs.map(a => a.name).join(', ')}]);
 
   return { ${contractVariableName} };
 });
 `;
-};
+  }
+
+  protected getReadmeTestingEnvironmentSetupSection(): string {
+    return '';
+  }
 
-const readme = (c: Contract) => `\
+  protected getReadmePrerequisitesSection(): string {
+    return '';
+  }
+
+  protected getReadme(c: Contract): string {
+    return `\
 # Sample Hardhat Project
 
 This project demonstrates a basic Hardhat use case. It comes with a contract generated by [OpenZeppelin Wizard](https://wizard.openzeppelin.com/), a test for that contract, ${c.upgradeable ? 'and a script that deploys that contract' : 'and a Hardhat Ignition module that deploys that contract'}.
 
-## Installing dependencies
+${this.getReadmePrerequisitesSection()}## Installing dependencies
 
 \`\`\`
 npm install
 \`\`\`
 
-## Testing the contract
+${this.getReadmeTestingEnvironmentSetupSection()}## Testing the contract
 
 \`\`\`
 npm test
@@ -197,43 +252,62 @@ You can target any network from your Hardhat config using:
 ${c.upgradeable ? 'npx hardhat run --network <network-name> scripts/deploy.ts' : `npx hardhat ignition deploy ignition/modules/${c.name}.ts --network <network-name>`}
 \`\`\`
 `;
+  }
 
-function getHardhatPlugins(c: Contract) {
-  const plugins = ['ethers'];
-  if (c.upgradeable) {
-    plugins.push('upgrades');
+  public getHardhatPlugins(c: Contract): string[] {
+    const plugins = ['ethers'];
+    if (c.upgradeable) {
+      plugins.push('upgrades');
+    }
+    return plugins;
   }
-  return plugins;
-}
 
-export async function zipHardhat(c: Contract, opts?: GenericOptions) {
-  const zip = new JSZip();
+  protected async getPackageJson(c: Contract): Promise<unknown> {
+    const { default: packageJson } = c.upgradeable
+      ? await import('./environments/hardhat/upgradeable/package.json')
+      : await import('./environments/hardhat/package.json');
+    packageJson.license = c.license;
+    return packageJson;
+  }
 
-  const { default: packageJson } = c.upgradeable
-    ? await import('./environments/hardhat/upgradeable/package.json')
-    : await import('./environments/hardhat/package.json');
-  packageJson.license = c.license;
+  protected async getPackageLock(c: Contract): Promise<unknown> {
+    const { default: packageLock } = c.upgradeable
+      ? await import('./environments/hardhat/upgradeable/package-lock.json')
+      : await import('./environments/hardhat/package-lock.json');
+    packageLock.packages[''].license = c.license;
+    return packageLock;
+  }
 
-  const { default: packageLock } = c.upgradeable
-    ? await import('./environments/hardhat/upgradeable/package-lock.json')
-    : await import('./environments/hardhat/package-lock.json');
-  packageLock.packages[''].license = c.license;
+  protected getPrintContract(c: Contract): string {
+    return printContract(c);
+  }
 
-  zip.file(`contracts/${c.name}.sol`, printContract(c));
-  zip.file('test/test.ts', test(c, opts));
+  async zipHardhat(c: Contract, opts?: GenericOptions): Promise<JSZip> {
+    const zip = new JSZip();
 
-  if (c.upgradeable) {
-    zip.file('scripts/deploy.ts', script(c));
-  } else {
-    zip.file(`ignition/modules/${c.name}.ts`, ignitionModule(c));
-  }
+    const packageJson = await this.getPackageJson(c);
+    const packageLock = await this.getPackageLock(c);
+
+    zip.file(`contracts/${c.name}.sol`, this.getPrintContract(c));
+    zip.file('test/test.ts', this.getTest(c, opts));
+
+    if (c.upgradeable) {
+      zip.file('scripts/deploy.ts', this.getScript(c));
+    } else {
+      zip.file(`ignition/modules/${c.name}.ts`, this.getIgnitionModule(c));
+    }
 
-  zip.file('.gitignore', gitIgnore);
-  zip.file('hardhat.config.ts', hardhatConfig(c.upgradeable));
-  zip.file('package.json', JSON.stringify(packageJson, null, 2));
-  zip.file(`package-lock.json`, JSON.stringify(packageLock, null, 2));
-  zip.file('README.md', readme(c));
-  zip.file('tsconfig.json', tsConfig);
+    zip.file('.gitignore', this.getGitIgnore());
+    zip.file('hardhat.config.ts', this.getHardhatConfig(c.upgradeable));
+    zip.file('package.json', JSON.stringify(packageJson, null, 2));
+    zip.file(`package-lock.json`, JSON.stringify(packageLock, null, 2));
+    zip.file('README.md', this.getReadme(c));
+    zip.file('tsconfig.json', this.getTsConfig());
+
+    return zip;
+  }
+}
 
-  return zip;
+export async function zipHardhat(c: Contract, opts?: GenericOptions): Promise<JSZip> {
+  return new HardhatZipGenerator().zipHardhat(c, opts);
 }