Merge branch 'master' into merge/release-v0.2

arr00 · arr00 · commit fea56060348c · 2025-08-15T07:41:50.000-04:00
diff --git a/.changeset/cold-nails-go.md b/.changeset/cold-nails-go.md
@@ -0,0 +1,7 @@
+---
+'openzeppelin-confidential-contracts': minor
+---
+
+`VestingWalletConfidential`: A vesting wallet that releases confidential tokens owned by it according to a defined vesting schedule.
+`VestingWalletCliffConfidential`: A variant of `VestingWalletConfidential` which adds a cliff period to the vesting schedule.
+`VestingWalletExecutorConfidential`: A variant of `VestingWalletConfidential` which allows a trusted executor to execute arbitrary calls from the vesting wallet.
diff --git a/.changeset/fifty-parrots-invite.md b/.changeset/fifty-parrots-invite.md
@@ -0,0 +1,5 @@
+---
+'openzeppelin-confidential-contracts': minor
+---
+
+`HandleAccessManager`: Minimal contract that adds a function to give allowance to callers for a given ciphertext handle.
diff --git a/.changeset/nasty-camels-attack.md b/.changeset/nasty-camels-attack.md
@@ -0,0 +1,5 @@
+---
+'openzeppelin-confidential-contracts': minor
+---
+
+`IConfidentialFungibleToken`: Prefix `totalSupply` and `balanceOf` functions with confidential.
diff --git a/.changeset/old-chefs-lie.md b/.changeset/old-chefs-lie.md
@@ -0,0 +1,5 @@
+---
+'openzeppelin-confidential-contracts': minor
+---
+
+`VestingWalletCliffExecutorConfidentialFactory`: Renamed to `VestingWalletConfidentialFactory` and default implementation removed in favor of a user-defined vesting wallet implementation.
diff --git a/.changeset/poor-colts-glow.md b/.changeset/poor-colts-glow.md
@@ -0,0 +1,5 @@
+---
+'openzeppelin-confidential-contracts': minor
+---
+
+`ERC7821WithExecutor`: Add an abstract contract that inherits from `ERC7821` and adds an `executor` role.
diff --git a/.changeset/six-walls-hug.md b/.changeset/six-walls-hug.md
@@ -0,0 +1,5 @@
+---
+'openzeppelin-confidential-contracts': minor
+---
+
+`ConfidentialFungibleTokenERC20Wrapper`: Add an internal function to allow overriding the maximum decimals value.
diff --git a/.changeset/tricky-boxes-train.md b/.changeset/tricky-boxes-train.md
@@ -0,0 +1,5 @@
+---
+'openzeppelin-confidential-contracts': minor
+---
+
+`VestingWalletCliffExecutorConfidentialFactory`: Fund multiple `VestingWalletCliffExecutorConfidential` in batch.
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
@@ -35,6 +35,8 @@ jobs:
       - run: npm run test
       - name: Check procedurally generated contracts are up-to-date
         run: npm run test:generation
+      - name: Check pragma validity
+        run: npm run test:pragma -- --concurrency 1
 
   coverage:
     runs-on: ubuntu-latest
diff --git a/.gitmodules b/.gitmodules
@@ -1,6 +1,8 @@
 [submodule "lib/openzeppelin-contracts"]
 	path = lib/openzeppelin-contracts
+	tag = v5.4.0
 	url = https://github.com/OpenZeppelin/openzeppelin-contracts
 [submodule "lib/openzeppelin-contracts-upgradeable"]
 	path = lib/openzeppelin-contracts-upgradeable
+	tag = v5.4.0
 	url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable
diff --git a/contracts/mocks/token/ConfidentialFungibleTokenReentrantMock.sol b/contracts/mocks/token/ConfidentialFungibleTokenReentrantMock.sol
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+import {euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {ConfidentialFungibleTokenMock} from "./ConfidentialFungibleTokenMock.sol";
+
+// solhint-disable func-name-mixedcase
+contract ConfidentialFungibleTokenReentrantMock is ConfidentialFungibleTokenMock {
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        string memory tokenURI_
+    ) ConfidentialFungibleTokenMock(name_, symbol_, tokenURI_) {}
+
+    function confidentialTransfer(address, euint64) public override returns (euint64 transferred) {
+        IVestingWalletConfidential(msg.sender).release(address(this));
+        transferred;
+    }
+}
+
+interface IVestingWalletConfidential {
+    function release(address token) external;
+}
diff --git a/contracts/package.json b/contracts/package.json
@@ -33,7 +33,7 @@
   "homepage": "https://openzeppelin.com/contracts/",
   "peerDependencies": {
     "@fhevm/solidity": "0.7.0",
-    "@openzeppelin/contracts": "^5.3.0",
-    "@openzeppelin/contracts-upgradeable": "^5.3.0"
+    "@openzeppelin/contracts": "^5.4.0",
+    "@openzeppelin/contracts-upgradeable": "^5.4.0"
   }
 }
diff --git a/contracts/token/ConfidentialFungibleToken.sol b/contracts/token/ConfidentialFungibleToken.sol
@@ -210,7 +210,7 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
      */
     function discloseEncryptedAmount(euint64 encryptedAmount) public virtual {
         require(
-            FHE.isAllowed(encryptedAmount, msg.sender) && FHE.isAllowed(encryptedAmount, address(this)),
+            FHE.isAllowed(encryptedAmount, msg.sender),
             ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(encryptedAmount, msg.sender)
         );
 
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -26,6 +26,7 @@
     "test": "hardhat test",
     "test:gas": "REPORT_GAS=true hardhat test",
     "test:generation": "scripts/checks/generation.sh",
+    "test:pragma": "npm run compile && scripts/checks/pragma-validity.js artifacts/build-info/*",
     "coverage": "SOLIDITY_COVERAGE=true hardhat coverage",
     "generate": "scripts/generate/run.js"
   },
diff --git a/scripts/checks/pragma-validity.js b/scripts/checks/pragma-validity.js
@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// TODO: Replace file content with symlink to lib/openzeppelin-contracts when available.
+const semver = require('semver');
+const pLimit = require('p-limit').default;
+
+const { hideBin } = require('yargs/helpers');
+const yargs = require('yargs/yargs');
+
+const getContractsMetadata = require('../get-contracts-metadata');
+const { compile } = require('../solc-versions');
+
+const {
+  argv: { pattern, skipPatterns, verbose, concurrency, _: artifacts },
+} = yargs(hideBin(process.argv))
+  .env('')
+  .options({
+    pattern: { alias: 'p', type: 'string', default: 'contracts/**/*.sol' },
+    skipPatterns: { alias: 's', type: 'string', default: 'contracts/mocks/**/*.sol' },
+    concurrency: { alias: 'c', type: 'number', default: 8 },
+    verbose: { alias: 'v', type: 'count' },
+  });
+
+const limit = pLimit(concurrency);
+Promise.all(
+  Object.entries(getContractsMetadata(pattern, skipPatterns, artifacts)).map(([source, { pragma }]) =>
+    limit(
+      (file, version) =>
+        compile(file, version).then(
+          () => {
+            verbose && console.log(`Compile ${file} using solc ${version}: ok`);
+          },
+          error => {
+            console.error(`Failed to compile ${file} using solc ${version}\n${error}`);
+            process.exitCode = 1;
+          },
+        ),
+      source,
+      semver.minVersion(pragma),
+    ),
+  ),
+).finally(() => {
+  if (!process.exitCode) {
+    console.log('All files can be compiled with the specified pragma.');
+  }
+});
diff --git a/scripts/get-contracts-metadata.js b/scripts/get-contracts-metadata.js
@@ -0,0 +1,56 @@
+// TODO: Replace file content with symlink to lib/openzeppelin-contracts when available.
+const fs = require('fs');
+const glob = require('glob');
+const match = require('micromatch');
+const path = require('path');
+const { findAll } = require('solidity-ast/utils');
+
+module.exports = function (
+  pattern = 'contracts/**/*.sol',
+  skipPatterns = ['contracts/mocks/**/*.sol'],
+  artifacts = [],
+) {
+  // Use available hardhat artifacts. They reliably identify pragmas and the contracts, libraries and interfaces
+  // definitions with minimal IO operations.
+  const metadata = Object.fromEntries(
+    artifacts.flatMap(artifact => {
+      const { output: solcOutput } = require(path.resolve(__dirname, '..', artifact));
+      return Object.keys(solcOutput.contracts)
+        .filter(source => match.all(source, pattern) && !match.any(source, skipPatterns))
+        .map(source => [
+          source,
+          {
+            pragma: Array.from(findAll('PragmaDirective', solcOutput.sources[source].ast))
+              .find(({ literals }) => literals.at(0) == 'solidity')
+              .literals.slice(1)
+              .join(''),
+            sources: Array.from(findAll('ImportDirective', solcOutput.sources[source].ast)).map(
+              ({ absolutePath }) => absolutePath,
+            ),
+            interface: Array.from(findAll('ContractDefinition', solcOutput.sources[source].ast)).every(
+              ({ contractKind }) => contractKind === 'interface',
+            ),
+          },
+        ]);
+    }),
+  );
+
+  // Artifacts are missing files that only include imports. We have a few of these in contracts/interfaces
+  // We add the missing metadata entries using the foundry artifacts
+  glob
+    .sync(pattern)
+    .filter(file => !match.any(file, skipPatterns) && !Object.hasOwn(metadata, file))
+    .forEach(file => {
+      const entries = glob.sync(`out/${path.basename(file)}/*`);
+      metadata[file] = {
+        pragma: fs.readFileSync(file, 'utf-8').match(/pragma solidity (?<pragma>[<>=^]*[0-9]+\.[0-9]+\.[0-9]+);/)
+          ?.groups.pragma,
+        sources: entries
+          .flatMap(entry => Object.keys(JSON.parse(fs.readFileSync(entry)).metadata.sources))
+          .filter(source => source !== file && match.all(source, pattern) && !match.any(source, skipPatterns)),
+        interface: entries.every(entry => path.basename(entry).match(/^I[A-Z]/)),
+      };
+    });
+
+  return metadata;
+};
diff --git a/scripts/helpers.js b/scripts/helpers.js
@@ -0,0 +1 @@
+../lib/openzeppelin-contracts/scripts/helpers.js
diff --git a/scripts/solc-versions.js b/scripts/solc-versions.js
@@ -0,0 +1,16 @@
+// TODO: Replace file content with symlink to lib/openzeppelin-contracts when available.
+const { exec } = require('child_process');
+const semver = require('semver');
+const { range } = require('./helpers');
+
+module.exports = {
+  versions: ['0.4.26', '0.5.16', '0.6.12', '0.7.6', '0.8.30']
+    .map(semver.parse)
+    .flatMap(({ major, minor, patch }) => range(patch + 1).map(p => `${major}.${minor}.${p}`)),
+  compile: (source, version) =>
+    new Promise((resolve, reject) =>
+      exec(`forge build ${source} --use ${version} --out out/solc-${version}`, error =>
+        error ? reject(error) : resolve(),
+      ),
+    ),
+};
diff --git a/test/finance/ERC7821WithExecutor.test.ts b/test/finance/ERC7821WithExecutor.test.ts
@@ -1,4 +1,4 @@
-import { ERC7821WithExecutor } from '../../types';
+import { $ERC7821WithExecutor } from '../../types/contracts-exposed/finance/ERC7821WithExecutor.sol/$ERC7821WithExecutor';
 import { anyValue } from '@nomicfoundation/hardhat-chai-matchers/withArgs';
 import { encodeMode, encodeBatch, CALL_TYPE_BATCH } from '@openzeppelin/contracts/test/helpers/erc7579';
 import { expect } from 'chai';
@@ -21,7 +21,7 @@ describe('ERC7821WithExecutor', function () {
 
     const executorWallet = (await ethers.deployContract('$ERC7821WithExecutor', [
       executor,
-    ])) as unknown as ERC7821WithExecutor;
+    ])) as unknown as $ERC7821WithExecutor;
 
     await (token as any)
       .connect(recipient)
@@ -56,5 +56,41 @@ describe('ERC7821WithExecutor', function () {
         .to.emit(this.token, 'ConfidentialTransfer')
         .withArgs(this.executorWallet, this.recipient, anyValue);
     });
+
+    it('should call if called by itself', async function () {
+      const balance = await this.token.confidentialBalanceOf(this.executorWallet);
+
+      await expect(
+        // caller is executor account
+        this.executorWallet.connect(this.executor).execute(
+          encodeMode({ callType: CALL_TYPE_BATCH }),
+          encodeBatch({
+            target: this.executorWallet.target,
+            value: 0n,
+            // then caller is `ERC7821WithExecutor` contract
+            data: this.executorWallet.interface.encodeFunctionData('execute(bytes32,bytes)', [
+              encodeMode({ callType: CALL_TYPE_BATCH }),
+              encodeBatch({
+                target: this.token,
+                value: 0n,
+                data: this.token.interface.encodeFunctionData('confidentialTransfer(address,bytes32)', [
+                  this.recipient.address,
+                  balance,
+                ]),
+              }),
+            ]),
+          }),
+        ),
+      )
+        .to.emit(this.token, 'ConfidentialTransfer')
+        .withArgs(this.executorWallet, this.recipient, anyValue);
+    });
+  });
+
+  it('should fail to init if not initializing', async function () {
+    await expect(this.executorWallet.$__ERC7821WithExecutor_init(this.executor)).to.be.revertedWithCustomError(
+      this.executorWallet,
+      'NotInitializing',
+    );
   });
 });
diff --git a/test/finance/VestingWalletConfidential.behavior.ts b/test/finance/VestingWalletConfidential.behavior.ts
@@ -1,7 +1,8 @@
+import { $ConfidentialFungibleTokenMock } from '../../types/contracts-exposed/mocks/token/ConfidentialFungibleTokenMock.sol/$ConfidentialFungibleTokenMock';
 import { FhevmType } from '@fhevm/hardhat-plugin';
 import { time } from '@nomicfoundation/hardhat-network-helpers';
 import { expect } from 'chai';
-import { fhevm } from 'hardhat';
+import { ethers, fhevm } from 'hardhat';
 
 function shouldBehaveLikeVestingConfidential() {
   describe('vesting', async function () {
@@ -43,6 +44,32 @@ function shouldBehaveLikeVestingConfidential() {
         fhevm.userDecryptEuint(FhevmType.euint64, balanceOfHandle, this.token.target, this.recipient),
       ).to.eventually.equal(this.vestingAmount);
     });
+
+    it('should not release if reentrancy', async function () {
+      const reentrantToken = await ethers.deployContract('$ConfidentialFungibleTokenReentrantMock', [
+        'name',
+        'symbol',
+        'uri',
+      ]);
+      const encryptedInput = await fhevm
+        .createEncryptedInput(await reentrantToken.getAddress(), this.holder.address)
+        .add64(1000)
+        .encrypt();
+      await (reentrantToken as any as $ConfidentialFungibleTokenMock)
+        .connect(this.holder)
+        ['$_mint(address,bytes32,bytes)'](this.vesting.target, encryptedInput.handles[0], encryptedInput.inputProof);
+
+      await expect(this.vesting.release(reentrantToken)).to.be.revertedWithCustomError(
+        this.vesting,
+        'ReentrancyGuardReentrantCall',
+      );
+    });
+  });
+
+  it('should fail to init if not initializing', async function () {
+    await expect(
+      this.vesting.$__VestingWalletConfidential_init(this.recipient, await time.latest(), 60 * 60),
+    ).to.be.revertedWithCustomError(this.vesting, 'NotInitializing');
   });
 }
 
diff --git a/test/helpers/iterate.js b/test/helpers/iterate.js
@@ -0,0 +1 @@
+../../lib/openzeppelin-contracts/test/helpers/iterate.js
diff --git a/test/helpers/strings.js b/test/helpers/strings.js
@@ -0,0 +1 @@
+../../lib/openzeppelin-contracts/test/helpers/strings.js

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'openzeppelin-confidential-contracts': minor
 +---
++
 +`HandleAccessManager`: Minimal contract that adds a function to give allowance to callers for a given ciphertext handle.