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

package/token/{extensions/ConfidentialFungibleTokenERC20Wrapper.sol → ERC7984/extensions/ERC7984ERC20Wrapper.sol}

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (token/extensions/ConfidentialFungibleTokenERC20Wrapper.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (token/ERC7984/extensions/ERC7984ERC20Wrapper.sol)
 
 pragma solidity ^0.8.27;
 
@@ -9,17 +9,17 @@ import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
-import {ConfidentialFungibleToken} from "./../ConfidentialFungibleToken.sol";
+import {ERC7984} from "./../ERC7984.sol";
 
 /**
- * @dev A wrapper contract built on top of {ConfidentialFungibleToken} that allows wrapping an `ERC20` token
- * into a confidential fungible token. The wrapper contract implements the `IERC1363Receiver` interface
+ * @dev A wrapper contract built on top of {ERC7984} that allows wrapping an `ERC20` token
+ * into an `ERC7984` token. The wrapper contract implements the `IERC1363Receiver` interface
  * which allows users to transfer `ERC1363` tokens directly to the wrapper with a callback to wrap the tokens.
  *
  * WARNING: Minting assumes the full amount of the underlying token transfer has been received, hence some non-standard
  * tokens such as fee-on-transfer or other deflationary-type tokens are not supported by this wrapper.
  */
-abstract contract ConfidentialFungibleTokenERC20Wrapper is ConfidentialFungibleToken, IERC1363Receiver {
+abstract contract ERC7984ERC20Wrapper is ERC7984, IERC1363Receiver {
     IERC20 private immutable _underlying;
     uint8 private immutable _decimals;
     uint256 private immutable _rate;
@@ -41,7 +41,7 @@ abstract contract ConfidentialFungibleTokenERC20Wrapper is ConfidentialFungibleT
         }
     }
 
-    /// @inheritdoc ConfidentialFungibleToken
+    /// @inheritdoc ERC7984
     function decimals() public view virtual override returns (uint8) {
         return _decimals;
     }
@@ -71,7 +71,7 @@ abstract contract ConfidentialFungibleTokenERC20Wrapper is ConfidentialFungibleT
         bytes calldata data
     ) public virtual returns (bytes4) {
         // check caller is the token contract
-        require(address(underlying()) == msg.sender, ConfidentialFungibleTokenUnauthorizedCaller(msg.sender));
+        require(address(underlying()) == msg.sender, ERC7984UnauthorizedCaller(msg.sender));
 
         // mint confidential token
         address to = data.length < 20 ? from : address(bytes20(data));
@@ -107,10 +107,7 @@ abstract contract ConfidentialFungibleTokenERC20Wrapper is ConfidentialFungibleT
      * NOTE: The caller *must* already be approved by ACL for the given `amount`.
      */
     function unwrap(address from, address to, euint64 amount) public virtual {
-        require(
-            FHE.isAllowed(amount, msg.sender),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(amount, msg.sender)
-        );
+        require(FHE.isAllowed(amount, msg.sender), ERC7984UnauthorizedUseOfEncryptedAmount(amount, msg.sender));
         _unwrap(from, to, amount);
     }
 
@@ -130,21 +127,22 @@ abstract contract ConfidentialFungibleTokenERC20Wrapper is ConfidentialFungibleT
     /**
      * @dev Fills an unwrap request for a given request id related to a decrypted unwrap amount.
      */
-    function finalizeUnwrap(uint256 requestID, uint64 amount, bytes[] memory signatures) public virtual {
-        FHE.checkSignatures(requestID, signatures);
+    function finalizeUnwrap(
+        uint256 requestID,
+        bytes calldata cleartexts,
+        bytes calldata decryptionProof
+    ) public virtual {
+        FHE.checkSignatures(requestID, cleartexts, decryptionProof);
         address to = _receivers[requestID];
-        require(to != address(0), ConfidentialFungibleTokenInvalidGatewayRequest(requestID));
+        require(to != address(0), ERC7984InvalidGatewayRequest(requestID));
         delete _receivers[requestID];
 
-        SafeERC20.safeTransfer(underlying(), to, amount * rate());
+        SafeERC20.safeTransfer(underlying(), to, abi.decode(cleartexts, (uint64)) * rate());
     }
 
     function _unwrap(address from, address to, euint64 amount) internal virtual {
-        require(to != address(0), ConfidentialFungibleTokenInvalidReceiver(to));
-        require(
-            from == msg.sender || isOperator(from, msg.sender),
-            ConfidentialFungibleTokenUnauthorizedSpender(from, msg.sender)
-        );
+        require(to != address(0), ERC7984InvalidReceiver(to));
+        require(from == msg.sender || isOperator(from, msg.sender), ERC7984UnauthorizedSpender(from, msg.sender));
 
         // try to burn, see how much we actually got
         euint64 burntAmount = _burn(from, amount);

package/token/ERC7984/extensions/ERC7984Freezable.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (token/ERC7984/extensions/ERC7984Freezable.sol)
+
+pragma solidity ^0.8.27;
+
+import {FHE, ebool, euint64, externalEuint64} from "@fhevm/solidity/lib/FHE.sol";
+import {FHESafeMath} from "../../../utils/FHESafeMath.sol";
+import {ERC7984} from "../ERC7984.sol";
+
+/**
+ * @dev Extension of {ERC7984} that implements a confidential
+ * freezing mechanism that can be managed by an authorized account with
+ * {setConfidentialFrozen} functions.
+ *
+ * The freezing mechanism provides the guarantee to the contract owner
+ * (e.g. a DAO or a well-configured multisig) that a specific confidential
+ * amount of tokens held by an account won't be transferable until those
+ * tokens are unfrozen.
+ *
+ * Inspired by https://github.com/OpenZeppelin/openzeppelin-community-contracts/blob/master/contracts/token/ERC20/extensions/ERC20Freezable.sol
+ */
+abstract contract ERC7984Freezable is ERC7984 {
+    /// @dev Confidential frozen amount of tokens per address.
+    mapping(address account => euint64 encryptedAmount) private _frozenBalances;
+
+    /// @dev Emitted when a confidential amount of token is frozen for an account
+    event TokensFrozen(address indexed account, euint64 encryptedAmount);
+
+    /// @dev Returns the confidential frozen balance of an account.
+    function confidentialFrozen(address account) public view virtual returns (euint64) {
+        return _frozenBalances[account];
+    }
+
+    /// @dev Returns the confidential available (unfrozen) balance of an account. Up to {confidentialBalanceOf}.
+    function confidentialAvailable(address account) public virtual returns (euint64) {
+        (ebool success, euint64 unfrozen) = FHESafeMath.tryDecrease(
+            confidentialBalanceOf(account),
+            confidentialFrozen(account)
+        );
+        return FHE.select(success, unfrozen, FHE.asEuint64(0));
+    }
+
+    /// @dev Internal function to freeze a confidential amount of tokens for an account.
+    function _setConfidentialFrozen(address account, euint64 encryptedAmount) internal virtual {
+        FHE.allowThis(encryptedAmount);
+        FHE.allow(encryptedAmount, account);
+        _frozenBalances[account] = encryptedAmount;
+        emit TokensFrozen(account, encryptedAmount);
+    }
+
+    /**
+     * @dev See {ERC7984-_update}.
+     *
+     * The `from` account must have sufficient unfrozen balance,
+     * otherwise 0 tokens are transferred.
+     * The default freezing behavior can be changed (for a pass-through for instance) by overriding
+     * {confidentialAvailable}.
+     */
+    function _update(address from, address to, euint64 encryptedAmount) internal virtual override returns (euint64) {
+        if (from != address(0)) {
+            euint64 unfrozen = confidentialAvailable(from);
+            encryptedAmount = FHE.select(FHE.le(encryptedAmount, unfrozen), encryptedAmount, FHE.asEuint64(0));
+        }
+        return super._update(from, to, encryptedAmount);
+    }
+}

package/token/ERC7984/extensions/ERC7984ObserverAccess.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (token/ERC7984/extensions/ERC7984ObserverAccess.sol)
+
+pragma solidity ^0.8.27;
+
+import {FHE, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {ERC7984} from "../ERC7984.sol";
+
+/**
+ * @dev Extension of {ERC7984} that allows each account to add a observer who is given
+ * permanent ACL access to its transfer and balance amounts. A observer can be added or removed at any point in time.
+ */
+abstract contract ERC7984ObserverAccess is ERC7984 {
+    mapping(address => address) private _observers;
+
+    /// @dev Emitted when the observer is changed for the given account `account`.
+    event ERC7984ObserverAccessObserverSet(address account, address oldObserver, address newObserver);
+
+    /// @dev Thrown when an account tries to set a `newObserver` for a given `account` without proper authority.
+    error Unauthorized();
+
+    /**
+     * @dev Sets the observer for the given account `account` to `newObserver`. Can be called by the
+     * account or the existing observer to abdicate the observer role (may only set to `address(0)`).
+     */
+    function setObserver(address account, address newObserver) public virtual {
+        address oldObserver = observer(account);
+        require(msg.sender == account || (msg.sender == oldObserver && newObserver == address(0)), Unauthorized());
+        if (oldObserver != newObserver) {
+            if (newObserver != address(0)) {
+                euint64 balanceHandle = confidentialBalanceOf(account);
+                if (FHE.isInitialized(balanceHandle)) {
+                    FHE.allow(balanceHandle, newObserver);
+                }
+            }
+
+            emit ERC7984ObserverAccessObserverSet(account, oldObserver, _observers[account] = newObserver);
+        }
+    }
+
+    /// @dev Returns the observer for the given account `account`.
+    function observer(address account) public view virtual returns (address) {
+        return _observers[account];
+    }
+
+    function _update(address from, address to, euint64 amount) internal virtual override returns (euint64 transferred) {
+        transferred = super._update(from, to, amount);
+
+        address fromObserver = observer(from);
+        address toObserver = observer(to);
+
+        if (fromObserver != address(0)) {
+            FHE.allow(confidentialBalanceOf(from), fromObserver);
+            FHE.allow(transferred, fromObserver);
+        }
+        if (toObserver != address(0)) {
+            FHE.allow(confidentialBalanceOf(to), toObserver);
+            if (toObserver != fromObserver) {
+                FHE.allow(transferred, toObserver);
+            }
+        }
+    }
+}

package/token/ERC7984/extensions/ERC7984Omnibus.sol

@@ -0,0 +1,209 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (token/ERC7984/extensions/ERC7984Omnibus.sol)
+
+pragma solidity ^0.8.27;
+
+import {FHE, euint64, externalEuint64, externalEaddress, eaddress} from "@fhevm/solidity/lib/FHE.sol";
+import {ERC7984} from "../ERC7984.sol";
+
+/**
+ * @dev Extension of {ERC7984} that emits additional events for omnibus transfers.
+ * These events contain encrypted addresses for the sub-account sender and recipient.
+ *
+ * NOTE: There is no onchain accounting for sub-accounts--integrators must track sub-account
+ * balances externally.
+ */
+abstract contract ERC7984Omnibus is ERC7984 {
+    /**
+     * @dev Emitted when a confidential transfer is made representing the onchain settlement of
+     * an omnibus transfer from `sender` to `recipient` of amount `amount`. Settlement occurs between
+     * `omnibusFrom` and `omnibusTo` and is represented in a matching {IERC7984-ConfidentialTransfer} event.
+     *
+     * NOTE: `omnibusFrom` and `omnibusTo` get permanent ACL allowances for `sender` and `recipient`.
+     */
+    event OmnibusConfidentialTransfer(
+        address indexed omnibusFrom,
+        address indexed omnibusTo,
+        eaddress sender,
+        eaddress indexed recipient,
+        euint64 amount
+    );
+
+    /**
+     * @dev The caller `user` does not have access to the encrypted address `addr`.
+     *
+     * NOTE: Try using the equivalent transfer function with an input proof.
+     */
+    error ERC7984UnauthorizedUseOfEncryptedAddress(eaddress addr, address user);
+
+    /// @dev Wraps the {confidentialTransfer-address-externalEuint64-bytes} function and emits the {OmnibusConfidentialTransfer} event.
+    function confidentialTransferOmnibus(
+        address omnibusTo,
+        externalEaddress externalSender,
+        externalEaddress externalRecipient,
+        externalEuint64 externalAmount,
+        bytes calldata inputProof
+    ) public virtual returns (euint64) {
+        return
+            confidentialTransferFromOmnibus(
+                msg.sender,
+                omnibusTo,
+                externalSender,
+                externalRecipient,
+                externalAmount,
+                inputProof
+            );
+    }
+
+    /// @dev Wraps the {confidentialTransfer-address-euint64} function and emits the {OmnibusConfidentialTransfer} event.
+    function confidentialTransferOmnibus(
+        address omnibusTo,
+        eaddress sender,
+        eaddress recipient,
+        euint64 amount
+    ) public virtual returns (euint64) {
+        return confidentialTransferFromOmnibus(msg.sender, omnibusTo, sender, recipient, amount);
+    }
+
+    /// @dev Wraps the {confidentialTransferFrom-address-address-externalEuint64-bytes} function and emits the {OmnibusConfidentialTransfer} event.
+    function confidentialTransferFromOmnibus(
+        address omnibusFrom,
+        address omnibusTo,
+        externalEaddress externalSender,
+        externalEaddress externalRecipient,
+        externalEuint64 externalAmount,
+        bytes calldata inputProof
+    ) public virtual returns (euint64) {
+        eaddress sender = FHE.fromExternal(externalSender, inputProof);
+        eaddress recipient = FHE.fromExternal(externalRecipient, inputProof);
+        euint64 amount = FHE.fromExternal(externalAmount, inputProof);
+
+        return _confidentialTransferFromOmnibus(omnibusFrom, omnibusTo, sender, recipient, amount);
+    }
+
+    /// @dev Wraps the {confidentialTransferFrom-address-address-euint64} function and emits the {OmnibusConfidentialTransfer} event.
+    function confidentialTransferFromOmnibus(
+        address omnibusFrom,
+        address omnibusTo,
+        eaddress sender,
+        eaddress recipient,
+        euint64 amount
+    ) public virtual returns (euint64) {
+        require(FHE.isAllowed(sender, msg.sender), ERC7984UnauthorizedUseOfEncryptedAddress(sender, msg.sender));
+        require(FHE.isAllowed(recipient, msg.sender), ERC7984UnauthorizedUseOfEncryptedAddress(recipient, msg.sender));
+
+        return _confidentialTransferFromOmnibus(omnibusFrom, omnibusTo, sender, recipient, amount);
+    }
+
+    /// @dev Wraps the {confidentialTransferAndCall-address-externalEuint64-bytes-bytes} function and emits the {OmnibusConfidentialTransfer} event.
+    function confidentialTransferAndCallOmnibus(
+        address omnibusTo,
+        externalEaddress externalSender,
+        externalEaddress externalRecipient,
+        externalEuint64 externalAmount,
+        bytes calldata inputProof,
+        bytes calldata data
+    ) public virtual returns (euint64) {
+        return
+            confidentialTransferFromAndCallOmnibus(
+                msg.sender,
+                omnibusTo,
+                externalSender,
+                externalRecipient,
+                externalAmount,
+                inputProof,
+                data
+            );
+    }
+
+    /// @dev Wraps the {confidentialTransferAndCall-address-euint64-bytes} function and emits the {OmnibusConfidentialTransfer} event.
+    function confidentialTransferAndCallOmnibus(
+        address omnibusTo,
+        eaddress sender,
+        eaddress recipient,
+        euint64 amount,
+        bytes calldata data
+    ) public virtual returns (euint64) {
+        return confidentialTransferFromAndCallOmnibus(msg.sender, omnibusTo, sender, recipient, amount, data);
+    }
+
+    /// @dev Wraps the {confidentialTransferFromAndCall-address-address-externalEuint64-bytes-bytes} function and emits the {OmnibusConfidentialTransfer} event.
+    function confidentialTransferFromAndCallOmnibus(
+        address omnibusFrom,
+        address omnibusTo,
+        externalEaddress externalSender,
+        externalEaddress externalRecipient,
+        externalEuint64 externalAmount,
+        bytes calldata inputProof,
+        bytes calldata data
+    ) public virtual returns (euint64) {
+        eaddress sender = FHE.fromExternal(externalSender, inputProof);
+        eaddress recipient = FHE.fromExternal(externalRecipient, inputProof);
+        euint64 amount = FHE.fromExternal(externalAmount, inputProof);
+
+        return _confidentialTransferFromAndCallOmnibus(omnibusFrom, omnibusTo, sender, recipient, amount, data);
+    }
+
+    /// @dev Wraps the {confidentialTransferFromAndCall-address-address-euint64-bytes} function and emits the {OmnibusConfidentialTransfer} event.
+    function confidentialTransferFromAndCallOmnibus(
+        address omnibusFrom,
+        address omnibusTo,
+        eaddress sender,
+        eaddress recipient,
+        euint64 amount,
+        bytes calldata data
+    ) public virtual returns (euint64) {
+        require(FHE.isAllowed(sender, msg.sender), ERC7984UnauthorizedUseOfEncryptedAddress(sender, msg.sender));
+        require(FHE.isAllowed(recipient, msg.sender), ERC7984UnauthorizedUseOfEncryptedAddress(recipient, msg.sender));
+
+        return _confidentialTransferFromAndCallOmnibus(omnibusFrom, omnibusTo, sender, recipient, amount, data);
+    }
+
+    /// @dev Handles the ACL allowances, does the transfer without a callback, and emits {OmnibusConfidentialTransfer}.
+    function _confidentialTransferFromOmnibus(
+        address omnibusFrom,
+        address omnibusTo,
+        eaddress sender,
+        eaddress recipient,
+        euint64 amount
+    ) internal virtual returns (euint64) {
+        FHE.allowThis(sender);
+        FHE.allow(sender, omnibusFrom);
+        FHE.allow(sender, omnibusTo);
+
+        FHE.allowThis(recipient);
+        FHE.allow(recipient, omnibusFrom);
+        FHE.allow(recipient, omnibusTo);
+
+        euint64 transferred = confidentialTransferFrom(omnibusFrom, omnibusTo, amount);
+        emit OmnibusConfidentialTransfer(omnibusFrom, omnibusTo, sender, recipient, transferred);
+        return transferred;
+    }
+
+    /// @dev Handles the ACL allowances, does the transfer with a callback, and emits {OmnibusConfidentialTransfer}.
+    function _confidentialTransferFromAndCallOmnibus(
+        address omnibusFrom,
+        address omnibusTo,
+        eaddress sender,
+        eaddress recipient,
+        euint64 amount,
+        bytes calldata data
+    ) internal virtual returns (euint64) {
+        euint64 transferred = confidentialTransferFromAndCall(omnibusFrom, omnibusTo, amount, data);
+
+        FHE.allowThis(sender);
+        FHE.allow(sender, omnibusFrom);
+        FHE.allow(sender, omnibusTo);
+
+        FHE.allowThis(recipient);
+        FHE.allow(recipient, omnibusFrom);
+        FHE.allow(recipient, omnibusTo);
+
+        FHE.allowThis(transferred);
+        FHE.allow(transferred, omnibusFrom);
+        FHE.allow(transferred, omnibusTo);
+
+        emit OmnibusConfidentialTransfer(omnibusFrom, omnibusTo, sender, recipient, transferred);
+        return transferred;
+    }
+}

package/token/ERC7984/extensions/ERC7984Restricted.sol

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (token/ERC7984/extensions/ERC7984Restricted.sol)
+
+pragma solidity ^0.8.27;
+
+import {ERC7984, euint64} from "../ERC7984.sol";
+
+/**
+ * @dev Extension of {ERC7984} that implements user account transfer restrictions through the
+ * {isUserAllowed} function. Inspired by
+ * https://github.com/OpenZeppelin/openzeppelin-community-contracts/blob/master/contracts/token/ERC20/extensions/ERC20Restricted.sol.
+ *
+ * By default, each account has no explicit restriction. The {isUserAllowed} function acts as
+ * a blocklist. Developers can override {isUserAllowed} to check that `restriction == ALLOWED`
+ * to implement an allowlist.
+ */
+abstract contract ERC7984Restricted is ERC7984 {
+    enum Restriction {
+        DEFAULT, // User has no explicit restriction
+        BLOCKED, // User is explicitly blocked
+        ALLOWED // User is explicitly allowed
+    }
+
+    mapping(address account => Restriction) private _restrictions;
+
+    /// @dev Emitted when a user account's restriction is updated.
+    event UserRestrictionUpdated(address indexed account, Restriction restriction);
+
+    /// @dev The operation failed because the user account is restricted.
+    error UserRestricted(address account);
+
+    /// @dev Returns the restriction of a user account.
+    function getRestriction(address account) public view virtual returns (Restriction) {
+        return _restrictions[account];
+    }
+
+    /**
+     * @dev Returns whether a user account is allowed to interact with the token.
+     *
+     * Default implementation only disallows explicitly BLOCKED accounts (i.e. a blocklist).
+     *
+     * To convert into an allowlist, override as:
+     *
+     * ```solidity
+     * function isUserAllowed(address account) public view virtual override returns (bool) {
+     *     return getRestriction(account) == Restriction.ALLOWED;
+     * }
+     * ```
+     */
+    function isUserAllowed(address account) public view virtual returns (bool) {
+        return getRestriction(account) != Restriction.BLOCKED; // i.e. DEFAULT && ALLOWED
+    }
+
+    /**
+     * @dev See {ERC7984-_update}. Enforces transfer restrictions (excluding minting and burning).
+     *
+     * Requirements:
+     *
+     * * `from` must be allowed to transfer tokens (see {isUserAllowed}).
+     * * `to` must be allowed to receive tokens (see {isUserAllowed}).
+     *
+     * The default restriction behaviour can be changed (for a pass-through for instance) by overriding
+     * {_checkSenderRestriction} and/or {_checkRecipientRestriction}.
+     */
+    function _update(address from, address to, euint64 value) internal virtual override returns (euint64) {
+        _checkSenderRestriction(from);
+        _checkRecipientRestriction(to);
+        return super._update(from, to, value);
+    }
+
+    /// @dev Updates the restriction of a user account.
+    function _setRestriction(address account, Restriction restriction) internal virtual {
+        if (getRestriction(account) != restriction) {
+            _restrictions[account] = restriction;
+            emit UserRestrictionUpdated(account, restriction);
+        } // no-op if restriction is unchanged
+    }
+
+    /// @dev Convenience function to block a user account (set to BLOCKED).
+    function _blockUser(address account) internal virtual {
+        _setRestriction(account, Restriction.BLOCKED);
+    }
+
+    /// @dev Convenience function to allow a user account (set to ALLOWED).
+    function _allowUser(address account) internal virtual {
+        _setRestriction(account, Restriction.ALLOWED);
+    }
+
+    /// @dev Convenience function to reset a user account to default restriction.
+    function _resetUser(address account) internal virtual {
+        _setRestriction(account, Restriction.DEFAULT);
+    }
+
+    /// @dev Checks if a user account is restricted. Reverts with {ERC20Restricted} if so.
+    function _checkRestriction(address account) internal view virtual {
+        require(isUserAllowed(account), UserRestricted(account));
+    }
+
+    /**
+     * @dev Internal function which checks restriction of the `from` account before a transfer.
+     * Working with {_update} function.
+     */
+    function _checkSenderRestriction(address account) internal view virtual {
+        if (account != address(0)) {
+            _checkRestriction(account); // Not minting
+        }
+    }
+
+    /**
+     * @dev Internal function which checks restriction of the `to` account before a transfer.
+     * Working with {_update} function.
+     */
+    function _checkRecipientRestriction(address account) internal view virtual {
+        if (account != address(0)) {
+            _checkRestriction(account); // Not burning
+        }
+    }
+}