Add Confidential tab

.changeset/floppy-berries-work.md

@@ -0,0 +1,8 @@
+---
+'@openzeppelin/wizard-confidential': minor
+'@openzeppelin/wizard': patch
+'@openzeppelin/contracts-mcp': patch
+'@openzeppelin/wizard-common': patch
+---
+
+Add support for Confidential Contracts Wizard

.github/workflows/test.yml

@@ -48,6 +48,7 @@ jobs:
         package:
           - solidity
           - cairo
+          - confidential
           - stellar
           - stylus
         # This variant config creates 2 branches of the matrix a default and a compile one to run the compile tests in their own job
@@ -59,6 +60,8 @@ jobs:
             variant: compile
           - package: cairo
             variant: compile
+          - package: confidential
+            variant: compile
           - package: stylus
             variant: compile
 

.gitignore

@@ -5,3 +5,5 @@ node_modules
 .env
 .env.local
 .vscode/settings.json
+
+fhevmTemp

package.json

@@ -18,6 +18,7 @@
   "workspaces": {
     "packages": [
       "packages/common",
+      "packages/core/solidity",
       "packages/core/*",
       "packages/mcp",
       "packages/ui"

packages/common/src/ai/descriptions/confidential.ts

@@ -0,0 +1,16 @@
+// IMPORTANT: This file must not have any imports since it is used in both Node and Deno environments,
+// which have different requirements for file extensions in import statements.
+
+export const confidentialPrompts = {
+  ConfidentialFungible:
+    'Make a confidential fungible token in Solidity according to the ERC-7984 standard, similar to ERC-20 but with confidentiality.',
+};
+
+export const confidentialConfidentialFungibleDescriptions = {
+  tokenURI: 'A URI related to the token.',
+  premint: 'The number of tokens to premint for the deployer.',
+  networkConfig: 'Specify the provider and network configuration to use for FHEVM contracts.',
+  wrappable: 'Whether to allow wrapping an ERC20 token into a confidential fungible token.',
+  votes:
+    'Whether to keep track of historical balances for voting in on-chain governance. Voting durations can be expressed as block numbers or timestamps.',
+};

packages/common/src/index.ts

@@ -3,3 +3,4 @@ export * from './ai/descriptions/cairo';
 export * from './ai/descriptions/solidity';
 export * from './ai/descriptions/stellar';
 export * from './ai/descriptions/stylus';
+export * from './ai/descriptions/confidential';

packages/core/confidential/.gitignore

@@ -0,0 +1,4 @@
+/cache
+/artifacts
+/contracts/generated
+/contract-version-pins.json

packages/core/confidential/CHANGELOG.md

@@ -0,0 +1,2 @@
+# Changelog
+

packages/core/confidential/NOTICE

@@ -0,0 +1,8 @@
+OpenZeppelin Contracts Wizard
+Copyright (C) 2021-2025  Zeppelin Group Ltd
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, version 3.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.

packages/core/confidential/README.md

@@ -0,0 +1,59 @@
+# OpenZeppelin Contracts Wizard for Confidential Contracts
+
+[![NPM Package](https://img.shields.io/npm/v/@openzeppelin/wizard-confidential?color=%234e5de4)](https://www.npmjs.com/package/@openzeppelin/wizard-confidential)
+
+Interactively build a contract out of components from OpenZeppelin Confidential Contracts. Provide parameters and desired features for the kind of contract that you want, and the Wizard will generate all of the code necessary. The resulting code is ready to be compiled and deployed, or it can serve as a starting point and customized further with application specific logic.
+
+This package provides a programmatic API. For a web interface, see https://wizard.openzeppelin.com
+
+### Installation
+
+`npm install @openzeppelin/wizard-confidential`
+
+### Contract types
+
+The following contract types are supported:
+- `confidentialFungible`
+
+Each contract type has functions/constants as defined below.
+
+### Functions
+
+#### `print`
+```js
+function print(opts?: ConfidentialFungibleOptions): string
+```
+
+Returns a string representation of a contract generated using the provided options. If `opts` is not provided, uses [`defaults`](#defaults).
+
+#### `defaults`
+```js
+const defaults: Required<ConfidentialFungibleOptions>
+```
+
+The default options that are used for [`print`](#print).
+
+### Examples
+
+Import the contract type(s) that you want to use from the `@openzeppelin/wizard-confidential` package:
+
+```js
+import { confidentialFungible } from '@openzeppelin/wizard-confidential';
+```
+
+To generate the source code for a confidential fungible contract with all of the default settings:
+```js
+const contract = confidentialFungible.print();
+```
+
+To generate the source code for a confidential fungible contract with a custom name, symbol, URI, and network configuration, along with some custom settings:
+```js
+const contract = confidentialFungible.print({
+  name: 'ExampleToken',
+  symbol: 'ETK',
+  tokenURI: 'https://example.com',
+  networkConfig: 'zama-sepolia',
+  premint: '1000000',
+  wrappable: true,
+});
+```

packages/core/confidential/ava.config.js

@@ -0,0 +1,9 @@
+module.exports = {
+  extensions: ['ts'],
+  require: ['ts-node/register'],
+  watchmode: {
+    ignoreChanges: ['contracts', 'artifacts', 'cache'],
+  },
+  timeout: '10m',
+  workerThreads: false,
+};

packages/core/confidential/contract-version-pins.d.ts

@@ -0,0 +1,8 @@
+export interface ContractVersionPins {
+  fhevmSolidityVersion: string;
+  confidentialContractsVersion: string;
+}
+
+declare const contractVersionPins: ContractVersionPins;
+
+export default contractVersionPins;

packages/core/confidential/hardhat.config.js

@@ -0,0 +1,19 @@
+const SOLIDITY_VERSION = require('@openzeppelin/wizard/src/solidity-version.json');
+
+require('@fhevm/hardhat-plugin');
+
+/**
+ * @type import('hardhat/config').HardhatUserConfig
+ */
+module.exports = {
+  solidity: {
+    version: SOLIDITY_VERSION,
+    settings: {
+      evmVersion: 'cancun',
+      optimizer: {
+        enabled: true,
+        runs: 200,
+      },
+    },
+  },
+};

packages/core/confidential/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@openzeppelin/wizard-confidential",
+  "version": "0.0.1-alpha.0",
+  "description": "A boilerplate generator to get started with OpenZeppelin Confidential Contracts",
+  "license": "AGPL-3.0-only",
+  "repository": "https://github.com/OpenZeppelin/contracts-wizard",
+  "main": "dist/index.js",
+  "ts:main": "src/index.ts",
+  "files": [
+    "LICENSE",
+    "NOTICE",
+    "/dist",
+    "/src",
+    "!**/*.test.*"
+  ],
+  "scripts": {
+    "prepare": "tsc && node dist/scripts/prepare.js",
+    "prepublish": "rimraf dist *.tsbuildinfo && hardhat clean",
+    "test": "ava",
+    "test:update-snapshots": "ava --update-snapshots",
+    "test:watch": "ava --watch",
+    "update-env": "rm ./src/environments/hardhat/package-lock.json && npm install --package-lock-only --prefix ./src/environments/hardhat"
+  },
+  "dependencies": {
+    "@openzeppelin/wizard": "^0.8.0"
+  },
+  "devDependencies": {
+    "@fhevm/core-contracts": "0.7.0-12",
+    "@fhevm/hardhat-plugin": "0.0.1-6",
+    "@fhevm/mock-utils": "^0.0.1-6",
+    "@fhevm/solidity": "0.7.0",
+    "@nomicfoundation/hardhat-ethers": "^3.1.0",
+    "@openzeppelin/confidential-contracts": "^0.2.0",
+    "@openzeppelin/contracts": "^5.4.0",
+    "@types/node": "^20.0.0",
+    "@types/semver": "^7.5.7",
+    "@zama-fhe/oracle-solidity": "^0.1.0",
+    "@zama-fhe/relayer-sdk": "^0.1.0-5",
+    "ava": "^6.0.0",
+    "hardhat": "^2.22.11",
+    "jszip": "^3.6.0",
+    "rimraf": "^5.0.0",
+    "semver": "^7.6.0",
+    "ts-node": "^10.4.0"
+  }
+}

packages/core/confidential/print-versioned.js

@@ -0,0 +1 @@
+module.exports = require('./dist/print-versioned');

packages/core/confidential/print-versioned.ts

@@ -0,0 +1 @@
+export * from './src/print-versioned';

packages/core/confidential/src/api.ts

@@ -0,0 +1,22 @@
+import type { CommonOptions } from './common-options';
+import type { ConfidentialFungibleOptions } from './confidentialFungible';
+import { printConfidentialFungible, defaults as confidentialFungibleDefaults } from './confidentialFungible';
+
+export interface WizardContractAPI<Options extends CommonOptions> {
+  /**
+   * Returns a string representation of a contract generated using the provided options. If opts is not provided, uses `defaults`.
+   */
+  print: (opts?: Options) => string;
+
+  /**
+   * The default options that are used for `print`.
+   */
+  defaults: Required<Options>;
+}
+
+export type ConfidentialFungible = WizardContractAPI<ConfidentialFungibleOptions>;
+
+export const confidentialFungible: ConfidentialFungible = {
+  print: printConfidentialFungible,
+  defaults: confidentialFungibleDefaults,
+};

packages/core/confidential/src/build-generic.ts

@@ -0,0 +1,23 @@
+import type { ConfidentialFungibleOptions } from './confidentialFungible';
+import { buildConfidentialFungible } from './confidentialFungible';
+import type { Contract } from '@openzeppelin/wizard';
+
+export interface KindedOptions {
+  ConfidentialFungible: { kind: 'ConfidentialFungible' } & ConfidentialFungibleOptions;
+}
+
+export type GenericOptions = KindedOptions[keyof KindedOptions];
+
+export function buildGeneric(opts: GenericOptions): Contract {
+  switch (opts.kind) {
+    case 'ConfidentialFungible':
+      return buildConfidentialFungible(opts);
+
+    default: {
+      // TODO: When other contract kinds are available, change the below to:
+      // const _: never = opts;
+      const _: never = opts.kind;
+      throw new Error('Unknown contract kind');
+    }
+  }
+}

packages/core/confidential/src/common-options.ts

@@ -0,0 +1,16 @@
+import type { Info } from '@openzeppelin/wizard';
+import { infoDefaults } from '@openzeppelin/wizard';
+
+export const defaults: Required<CommonOptions> = {
+  info: infoDefaults,
+} as const;
+
+export interface CommonOptions {
+  info?: Info;
+}
+
+export function withCommonDefaults(opts: CommonOptions): Required<CommonOptions> {
+  return {
+    info: { ...defaults.info, ...(opts.info ?? {}) },
+  };
+}