@openzeppelin/confidential-contracts 0.2.0 → 0.3.0-rc.0

package/build/contracts/VestingWalletConfidentialFactory.json

@@ -55,7 +55,7 @@
         {
           "indexed": true,
           "internalType": "address",
-          "name": "confidentialFungibleToken",
+          "name": "token",
           "type": "address"
         },
         {
@@ -78,7 +78,7 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "confidentialFungibleToken",
+          "name": "token",
           "type": "address"
         },
         {

package/finance/VestingWalletConfidential.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (finance/VestingWalletConfidential.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (finance/VestingWalletConfidential.sol)
 pragma solidity ^0.8.24;
 
 import {FHE, ebool, euint64, euint128} from "@fhevm/solidity/lib/FHE.sol";
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import {ReentrancyGuardTransient} from "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
-import {IConfidentialFungibleToken} from "./../interfaces/IConfidentialFungibleToken.sol";
+import {IERC7984} from "./../interfaces/IERC7984.sol";
 
 /**
- * @dev A vesting wallet is an ownable contract that can receive ConfidentialFungibleTokens, and release these
+ * @dev A vesting wallet is an ownable contract that can receive ERC7984 tokens, and release these
  * assets to the wallet owner, also referred to as "beneficiary", according to a vesting schedule.
  *
  * Any assets transferred to this contract will follow the vesting schedule as if they were locked from the beginning.
@@ -63,7 +63,7 @@ abstract contract VestingWalletConfidential is OwnableUpgradeable, ReentrancyGua
 
     /**
      * @dev Getter for the amount of releasable `token` tokens. `token` should be the address of an
-     * {IConfidentialFungibleToken} contract.
+     * {IERC7984} contract.
      */
     function releasable(address token) public virtual returns (euint64) {
         euint128 vestedAmount_ = vestedAmount(token, uint48(block.timestamp));
@@ -80,7 +80,7 @@ abstract contract VestingWalletConfidential is OwnableUpgradeable, ReentrancyGua
     function release(address token) public virtual nonReentrant {
         euint64 amount = releasable(token);
         FHE.allowTransient(amount, token);
-        euint64 amountSent = IConfidentialFungibleToken(token).confidentialTransfer(owner(), amount);
+        euint64 amountSent = IERC7984(token).confidentialTransfer(owner(), amount);
 
         // This could overflow if the total supply is resent `type(uint128).max/type(uint64).max` times. This is an accepted risk.
         euint128 newReleasedAmount = FHE.add(released(token), amountSent);
@@ -96,10 +96,7 @@ abstract contract VestingWalletConfidential is OwnableUpgradeable, ReentrancyGua
      */
     function vestedAmount(address token, uint48 timestamp) public virtual returns (euint128) {
         return
-            _vestingSchedule(
-                FHE.add(released(token), IConfidentialFungibleToken(token).confidentialBalanceOf(address(this))),
-                timestamp
-            );
+            _vestingSchedule(FHE.add(released(token), IERC7984(token).confidentialBalanceOf(address(this))), timestamp);
     }
 
     /**

package/finance/VestingWalletConfidentialFactory.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (finance/VestingWalletConfidentialFactory.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (finance/VestingWalletConfidentialFactory.sol)
 pragma solidity ^0.8.27;
 
 import {FHE, euint64, externalEuint64} from "@fhevm/solidity/lib/FHE.sol";
 import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
-import {IConfidentialFungibleToken} from "./../interfaces/IConfidentialFungibleToken.sol";
+import {IERC7984} from "./../interfaces/IERC7984.sol";
 
 /**
  * @dev A factory which enables batch funding of vesting wallets.
@@ -23,7 +23,7 @@ abstract contract VestingWalletConfidentialFactory {
     /// @dev Emitted for each vesting wallet funded within a batch.
     event VestingWalletConfidentialFunded(
         address indexed vestingWalletConfidential,
-        address indexed confidentialFungibleToken,
+        address indexed token,
         euint64 transferredAmount,
         bytes initArgs
     );
@@ -43,7 +43,7 @@ abstract contract VestingWalletConfidentialFactory {
      * Emits a {VestingWalletConfidentialFunded} event for each funded vesting plan.
      */
     function batchFundVestingWalletConfidential(
-        address confidentialFungibleToken,
+        address token,
         VestingPlan[] calldata vestingPlans,
         bytes calldata inputProof
     ) public virtual {
@@ -55,19 +55,14 @@ abstract contract VestingWalletConfidentialFactory {
             address vestingWalletAddress = predictVestingWalletConfidential(vestingPlan.initArgs);
 
             euint64 encryptedAmount = FHE.fromExternal(vestingPlan.encryptedAmount, inputProof);
-            FHE.allowTransient(encryptedAmount, confidentialFungibleToken);
-            euint64 transferredAmount = IConfidentialFungibleToken(confidentialFungibleToken).confidentialTransferFrom(
+            FHE.allowTransient(encryptedAmount, token);
+            euint64 transferredAmount = IERC7984(token).confidentialTransferFrom(
                 msg.sender,
                 vestingWalletAddress,
                 encryptedAmount
             );
 
-            emit VestingWalletConfidentialFunded(
-                vestingWalletAddress,
-                confidentialFungibleToken,
-                transferredAmount,
-                vestingPlan.initArgs
-            );
+            emit VestingWalletConfidentialFunded(vestingWalletAddress, token, transferredAmount, vestingPlan.initArgs);
         }
     }
 

package/interfaces/{IConfidentialFungibleToken.sol → IERC7984.sol}

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (interfaces/IConfidentialFungibleToken.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (interfaces/IERC7984.sol)
 pragma solidity ^0.8.24;
 
 import {euint64, externalEuint64} from "@fhevm/solidity/lib/FHE.sol";
 
 /// @dev Draft interface for a confidential fungible token standard utilizing the Zama FHE library.
-interface IConfidentialFungibleToken {
+interface IERC7984 {
     /**
      * @dev Emitted when the expiration timestamp for an operator `operator` is updated for a given `holder`.
      * The operator may move any amount of tokens on behalf of the holder until the timestamp `until`.
@@ -32,8 +32,8 @@ interface IConfidentialFungibleToken {
     /// @dev Returns the number of decimals of the token. Recommended to be 6.
     function decimals() external view returns (uint8);
 
-    /// @dev Returns the token URI.
-    function tokenURI() external view returns (string memory);
+    /// @dev Returns the contract URI. See [ERC-7572](https://eips.ethereum.org/EIPS/eip-7572) for details.
+    function contractURI() external view returns (string memory);
 
     /// @dev Returns the confidential total supply of the token.
     function confidentialTotalSupply() external view returns (euint64);
@@ -91,7 +91,7 @@ interface IConfidentialFungibleToken {
      * @dev Similar to {confidentialTransfer-address-externalEuint64-bytes} but with a callback to `to` after
      * the transfer.
      *
-     * The callback is made to the {IConfidentialFungibleTokenReceiver-onConfidentialTransferReceived} function on the
+     * The callback is made to the {IERC7984Receiver-onConfidentialTransferReceived} function on the
      * to address with the actual transferred amount (may differ from the given `encryptedAmount`) and the given
      * data `data`.
      */

package/interfaces/{IConfidentialFungibleTokenReceiver.sol → IERC7984Receiver.sol}

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (interfaces/IConfidentialFungibleTokenReceiver.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (interfaces/IERC7984Receiver.sol)
 pragma solidity ^0.8.24;
 
 import {ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
 
-/// @dev Interface for contracts that can receive confidential token transfers with a callback.
-interface IConfidentialFungibleTokenReceiver {
+/// @dev Interface for contracts that can receive ERC7984 transfers with a callback.
+interface IERC7984Receiver {
     /**
      * @dev Called upon receiving a confidential token transfer. Returns an encrypted boolean indicating success
      * of the callback. If false is returned, the transfer must be reversed.

package/interfaces/IERC7984Rwa.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (interfaces/IERC7984Rwa.sol)
+pragma solidity ^0.8.24;
+
+import {externalEuint64, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {IERC165} from "@openzeppelin/contracts/interfaces/IERC165.sol";
+import {IERC7984} from "./IERC7984.sol";
+
+/// @dev Interface for confidential RWA contracts.
+interface IERC7984Rwa is IERC7984, IERC165 {
+    /// @dev Returns true if the contract is paused, false otherwise.
+    function paused() external view returns (bool);
+    /// @dev Returns whether an account is allowed to interact with the token.
+    function isUserAllowed(address account) external view returns (bool);
+    /// @dev Returns the confidential frozen balance of an account.
+    function confidentialFrozen(address account) external view returns (euint64);
+    /// @dev Returns the confidential available (unfrozen) balance of an account. Up to {IERC7984-confidentialBalanceOf}.
+    function confidentialAvailable(address account) external returns (euint64);
+    /// @dev Pauses contract.
+    function pause() external;
+    /// @dev Unpauses contract.
+    function unpause() external;
+    /// @dev Blocks a user account.
+    function blockUser(address account) external;
+    /// @dev Unblocks a user account.
+    function unblockUser(address account) external;
+    /// @dev Sets confidential amount of token for an account as frozen with proof.
+    function setConfidentialFrozen(
+        address account,
+        externalEuint64 encryptedAmount,
+        bytes calldata inputProof
+    ) external;
+    /// @dev Sets confidential amount of token for an account as frozen.
+    function setConfidentialFrozen(address account, euint64 encryptedAmount) external;
+    /// @dev Mints confidential amount of tokens to account with proof.
+    function confidentialMint(
+        address to,
+        externalEuint64 encryptedAmount,
+        bytes calldata inputProof
+    ) external returns (euint64);
+    /// @dev Mints confidential amount of tokens to account.
+    function confidentialMint(address to, euint64 encryptedAmount) external returns (euint64);
+    /// @dev Burns confidential amount of tokens from account with proof.
+    function confidentialBurn(
+        address account,
+        externalEuint64 encryptedAmount,
+        bytes calldata inputProof
+    ) external returns (euint64);
+    /// @dev Burns confidential amount of tokens from account.
+    function confidentialBurn(address account, euint64 encryptedAmount) external returns (euint64);
+    /// @dev Forces transfer of confidential amount of tokens from account to account with proof by skipping compliance checks.
+    function forceConfidentialTransferFrom(
+        address from,
+        address to,
+        externalEuint64 encryptedAmount,
+        bytes calldata inputProof
+    ) external returns (euint64);
+    /// @dev Forces transfer of confidential amount of tokens from account to account by skipping compliance checks.
+    function forceConfidentialTransferFrom(
+        address from,
+        address to,
+        euint64 encryptedAmount
+    ) external returns (euint64);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openzeppelin/confidential-contracts",
   "description": "Smart Contract library for use with confidential coprocessors",
-  "version": "0.2.0",
+  "version": "0.3.0-rc.0",
   "files": [
     "**/*.sol",
     "/build/contracts/*.json",
@@ -32,8 +32,8 @@
   },
   "homepage": "https://openzeppelin.com/contracts/",
   "peerDependencies": {
-    "@fhevm/solidity": "0.7.0",
-    "@openzeppelin/contracts": "^5.3.0",
-    "@openzeppelin/contracts-upgradeable": "^5.3.0"
+    "@fhevm/solidity": "0.8.0",
+    "@openzeppelin/contracts": "^5.4.0",
+    "@openzeppelin/contracts-upgradeable": "^5.4.0"
   }
 }

package/token/{ConfidentialFungibleToken.sol → ERC7984/ERC7984.sol}

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (token/ConfidentialFungibleToken.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (token/ERC7984/ERC7984.sol)
 pragma solidity ^0.8.27;
 
 import {FHE, externalEuint64, ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
-import {IConfidentialFungibleToken} from "./../interfaces/IConfidentialFungibleToken.sol";
-import {FHESafeMath} from "./../utils/FHESafeMath.sol";
-import {ConfidentialFungibleTokenUtils} from "./utils/ConfidentialFungibleTokenUtils.sol";
+import {IERC7984} from "./../../interfaces/IERC7984.sol";
+import {FHESafeMath} from "./../../utils/FHESafeMath.sol";
+import {ERC7984Utils} from "./utils/ERC7984Utils.sol";
 
 /**
- * @dev Reference implementation for {IConfidentialFungibleToken}.
+ * @dev Reference implementation for {IERC7984}.
  *
  * This contract implements a fungible token where balances and transfers are encrypted using the Zama fhEVM,
  * providing confidentiality to users. Token amounts are stored as encrypted, unsigned integers (`euint64`)
@@ -22,87 +22,86 @@ import {ConfidentialFungibleTokenUtils} from "./utils/ConfidentialFungibleTokenU
  * - Transfer and call pattern
  * - Safe overflow/underflow handling for FHE operations
  */
-abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
+abstract contract ERC7984 is IERC7984 {
     mapping(address holder => euint64) private _balances;
     mapping(address holder => mapping(address spender => uint48)) private _operators;
-    mapping(uint256 requestId => euint64 encryptedAmount) private _requestHandles;
     euint64 private _totalSupply;
     string private _name;
     string private _symbol;
-    string private _tokenURI;
+    string private _contractURI;
 
     /// @dev The given receiver `receiver` is invalid for transfers.
-    error ConfidentialFungibleTokenInvalidReceiver(address receiver);
+    error ERC7984InvalidReceiver(address receiver);
 
     /// @dev The given sender `sender` is invalid for transfers.
-    error ConfidentialFungibleTokenInvalidSender(address sender);
+    error ERC7984InvalidSender(address sender);
 
     /// @dev The given holder `holder` is not authorized to spend on behalf of `spender`.
-    error ConfidentialFungibleTokenUnauthorizedSpender(address holder, address spender);
+    error ERC7984UnauthorizedSpender(address holder, address spender);
 
     /// @dev The holder `holder` is trying to send tokens but has a balance of 0.
-    error ConfidentialFungibleTokenZeroBalance(address holder);
+    error ERC7984ZeroBalance(address holder);
 
     /**
      * @dev The caller `user` does not have access to the encrypted amount `amount`.
      *
      * NOTE: Try using the equivalent transfer function with an input proof.
      */
-    error ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(euint64 amount, address user);
+    error ERC7984UnauthorizedUseOfEncryptedAmount(euint64 amount, address user);
 
     /// @dev The given caller `caller` is not authorized for the current operation.
-    error ConfidentialFungibleTokenUnauthorizedCaller(address caller);
+    error ERC7984UnauthorizedCaller(address caller);
 
     /// @dev The given gateway request ID `requestId` is invalid.
-    error ConfidentialFungibleTokenInvalidGatewayRequest(uint256 requestId);
+    error ERC7984InvalidGatewayRequest(uint256 requestId);
 
-    constructor(string memory name_, string memory symbol_, string memory tokenURI_) {
+    constructor(string memory name_, string memory symbol_, string memory contractURI_) {
         _name = name_;
         _symbol = symbol_;
-        _tokenURI = tokenURI_;
+        _contractURI = contractURI_;
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function name() public view virtual returns (string memory) {
         return _name;
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function symbol() public view virtual returns (string memory) {
         return _symbol;
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function decimals() public view virtual returns (uint8) {
         return 6;
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
-    function tokenURI() public view virtual returns (string memory) {
-        return _tokenURI;
+    /// @inheritdoc IERC7984
+    function contractURI() public view virtual returns (string memory) {
+        return _contractURI;
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function confidentialTotalSupply() public view virtual returns (euint64) {
         return _totalSupply;
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function confidentialBalanceOf(address account) public view virtual returns (euint64) {
         return _balances[account];
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function isOperator(address holder, address spender) public view virtual returns (bool) {
         return holder == spender || block.timestamp <= _operators[holder][spender];
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function setOperator(address operator, uint48 until) public virtual {
         _setOperator(msg.sender, operator, until);
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function confidentialTransfer(
         address to,
         externalEuint64 encryptedAmount,
@@ -111,43 +110,37 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
         return _transfer(msg.sender, to, FHE.fromExternal(encryptedAmount, inputProof));
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function confidentialTransfer(address to, euint64 amount) public virtual returns (euint64) {
-        require(
-            FHE.isAllowed(amount, msg.sender),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(amount, msg.sender)
-        );
+        require(FHE.isAllowed(amount, msg.sender), ERC7984UnauthorizedUseOfEncryptedAmount(amount, msg.sender));
         return _transfer(msg.sender, to, amount);
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function confidentialTransferFrom(
         address from,
         address to,
         externalEuint64 encryptedAmount,
         bytes calldata inputProof
     ) public virtual returns (euint64 transferred) {
-        require(isOperator(from, msg.sender), ConfidentialFungibleTokenUnauthorizedSpender(from, msg.sender));
+        require(isOperator(from, msg.sender), ERC7984UnauthorizedSpender(from, msg.sender));
         transferred = _transfer(from, to, FHE.fromExternal(encryptedAmount, inputProof));
         FHE.allowTransient(transferred, msg.sender);
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function confidentialTransferFrom(
         address from,
         address to,
         euint64 amount
     ) public virtual returns (euint64 transferred) {
-        require(
-            FHE.isAllowed(amount, msg.sender),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(amount, msg.sender)
-        );
-        require(isOperator(from, msg.sender), ConfidentialFungibleTokenUnauthorizedSpender(from, msg.sender));
+        require(FHE.isAllowed(amount, msg.sender), ERC7984UnauthorizedUseOfEncryptedAmount(amount, msg.sender));
+        require(isOperator(from, msg.sender), ERC7984UnauthorizedSpender(from, msg.sender));
         transferred = _transfer(from, to, amount);
         FHE.allowTransient(transferred, msg.sender);
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function confidentialTransferAndCall(
         address to,
         externalEuint64 encryptedAmount,
@@ -158,21 +151,18 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
         FHE.allowTransient(transferred, msg.sender);
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function confidentialTransferAndCall(
         address to,
         euint64 amount,
         bytes calldata data
     ) public virtual returns (euint64 transferred) {
-        require(
-            FHE.isAllowed(amount, msg.sender),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(amount, msg.sender)
-        );
+        require(FHE.isAllowed(amount, msg.sender), ERC7984UnauthorizedUseOfEncryptedAmount(amount, msg.sender));
         transferred = _transferAndCall(msg.sender, to, amount, data);
         FHE.allowTransient(transferred, msg.sender);
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function confidentialTransferFromAndCall(
         address from,
         address to,
@@ -180,29 +170,26 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
         bytes calldata inputProof,
         bytes calldata data
     ) public virtual returns (euint64 transferred) {
-        require(isOperator(from, msg.sender), ConfidentialFungibleTokenUnauthorizedSpender(from, msg.sender));
+        require(isOperator(from, msg.sender), ERC7984UnauthorizedSpender(from, msg.sender));
         transferred = _transferAndCall(from, to, FHE.fromExternal(encryptedAmount, inputProof), data);
         FHE.allowTransient(transferred, msg.sender);
     }
 
-    /// @inheritdoc IConfidentialFungibleToken
+    /// @inheritdoc IERC7984
     function confidentialTransferFromAndCall(
         address from,
         address to,
         euint64 amount,
         bytes calldata data
     ) public virtual returns (euint64 transferred) {
-        require(
-            FHE.isAllowed(amount, msg.sender),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(amount, msg.sender)
-        );
-        require(isOperator(from, msg.sender), ConfidentialFungibleTokenUnauthorizedSpender(from, msg.sender));
+        require(FHE.isAllowed(amount, msg.sender), ERC7984UnauthorizedUseOfEncryptedAmount(amount, msg.sender));
+        require(isOperator(from, msg.sender), ERC7984UnauthorizedSpender(from, msg.sender));
         transferred = _transferAndCall(from, to, amount, data);
         FHE.allowTransient(transferred, msg.sender);
     }
 
     /**
-     * @dev Discloses an encrypted amount `encryptedAmount` publicly via an {IConfidentialFungibleToken-AmountDisclosed}
+     * @dev Discloses an encrypted amount `encryptedAmount` publicly via an {IERC7984-AmountDisclosed}
      * event. The caller and this contract must be authorized to use the encrypted amount on the ACL.
      *
      * NOTE: This is an asynchronous operation where the actual decryption happens off-chain and
@@ -210,29 +197,34 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
      */
     function discloseEncryptedAmount(euint64 encryptedAmount) public virtual {
         require(
-            FHE.isAllowed(encryptedAmount, msg.sender) && FHE.isAllowed(encryptedAmount, address(this)),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(encryptedAmount, msg.sender)
+            FHE.isAllowed(encryptedAmount, msg.sender),
+            ERC7984UnauthorizedUseOfEncryptedAmount(encryptedAmount, msg.sender)
         );
 
         bytes32[] memory cts = new bytes32[](1);
         cts[0] = euint64.unwrap(encryptedAmount);
-        uint256 requestID = FHE.requestDecryption(cts, this.finalizeDiscloseEncryptedAmount.selector);
-        _requestHandles[requestID] = encryptedAmount;
+        FHE.requestDecryption(cts, this.finalizeDiscloseEncryptedAmount.selector);
     }
 
-    /// @dev Finalizes a disclose encrypted amount request.
+    /**
+     * @dev Finalizes a disclose encrypted amount request.
+     * For gas saving purposes, the `requestId` might not be related to a
+     * {discloseEncryptedAmount} request. As a result, the current {finalizeDiscloseEncryptedAmount}
+     * function might emit a disclosed amount related to another decryption request context.
+     * In this case it would only display public information
+     * since the handle would have already been allowed for public decryption through a previous
+     * `FHE.requestDecryption` call.
+     * The downside of this behavior is that a {finalizeDiscloseEncryptedAmount} watcher might observe
+     * unexpected `AmountDisclosed` events.
+     */
     function finalizeDiscloseEncryptedAmount(
         uint256 requestId,
-        uint64 amount,
-        bytes[] memory signatures
+        bytes calldata cleartexts,
+        bytes calldata decryptionProof
     ) public virtual {
-        FHE.checkSignatures(requestId, signatures);
-
-        euint64 requestHandle = _requestHandles[requestId];
-        require(FHE.isInitialized(requestHandle), ConfidentialFungibleTokenInvalidGatewayRequest(requestId));
-        emit AmountDisclosed(requestHandle, amount);
-
-        _requestHandles[requestId] = euint64.wrap(0);
+        FHE.checkSignatures(requestId, cleartexts, decryptionProof);
+        euint64 requestHandle = euint64.wrap(FHE.loadRequestedHandles(requestId)[0]);
+        emit AmountDisclosed(requestHandle, abi.decode(cleartexts, (uint64)));
     }
 
     function _setOperator(address holder, address operator, uint48 until) internal virtual {
@@ -241,18 +233,18 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
     }
 
     function _mint(address to, euint64 amount) internal returns (euint64 transferred) {
-        require(to != address(0), ConfidentialFungibleTokenInvalidReceiver(address(0)));
+        require(to != address(0), ERC7984InvalidReceiver(address(0)));
         return _update(address(0), to, amount);
     }
 
     function _burn(address from, euint64 amount) internal returns (euint64 transferred) {
-        require(from != address(0), ConfidentialFungibleTokenInvalidSender(address(0)));
+        require(from != address(0), ERC7984InvalidSender(address(0)));
         return _update(from, address(0), amount);
     }
 
     function _transfer(address from, address to, euint64 amount) internal returns (euint64 transferred) {
-        require(from != address(0), ConfidentialFungibleTokenInvalidSender(address(0)));
-        require(to != address(0), ConfidentialFungibleTokenInvalidReceiver(address(0)));
+        require(from != address(0), ERC7984InvalidSender(address(0)));
+        require(to != address(0), ERC7984InvalidReceiver(address(0)));
         return _update(from, to, amount);
     }
 
@@ -266,7 +258,7 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
         euint64 sent = _transfer(from, to, amount);
 
         // Perform callback
-        ebool success = ConfidentialFungibleTokenUtils.checkOnTransferReceived(msg.sender, from, to, sent, data);
+        ebool success = ERC7984Utils.checkOnTransferReceived(msg.sender, from, to, sent, data);
 
         // Try to refund if callback fails
         euint64 refund = _update(to, from, FHE.select(success, FHE.asEuint64(0), sent));
@@ -283,7 +275,7 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
             _totalSupply = ptr;
         } else {
             euint64 fromBalance = _balances[from];
-            require(FHE.isInitialized(fromBalance), ConfidentialFungibleTokenZeroBalance(from));
+            require(FHE.isInitialized(fromBalance), ERC7984ZeroBalance(from));
             (success, ptr) = FHESafeMath.tryDecrease(fromBalance, amount);
             FHE.allowThis(ptr);
             FHE.allow(ptr, from);