@openzeppelin/confidential-contracts 0.3.1 → 0.4.0-rc.0

package/token/ERC7984/extensions/ERC7984ERC20Wrapper.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.3.1) (token/ERC7984/extensions/ERC7984ERC20Wrapper.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.4.0-rc.0) (token/ERC7984/extensions/ERC7984ERC20Wrapper.sol)
 
 pragma solidity ^0.8.27;
 
@@ -8,7 +8,10 @@ import {IERC1363Receiver} from "@openzeppelin/contracts/interfaces/IERC1363Recei
 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 {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import {IERC7984} from "../../../interfaces/IERC7984.sol";
+import {IERC7984ERC20Wrapper} from "../../../interfaces/IERC7984ERC20Wrapper.sol";
 import {ERC7984} from "./../ERC7984.sol";
 
 /**
@@ -19,17 +22,14 @@ import {ERC7984} from "./../ERC7984.sol";
  * 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 ERC7984ERC20Wrapper is ERC7984, IERC1363Receiver {
+abstract contract ERC7984ERC20Wrapper is ERC7984, IERC7984ERC20Wrapper, IERC1363Receiver {
     IERC20 private immutable _underlying;
     uint8 private immutable _decimals;
     uint256 private immutable _rate;
 
-    mapping(euint64 unwrapAmount => address recipient) private _unwrapRequests;
+    mapping(bytes32 unwrapRequestId => address recipient) private _unwrapRequests;
 
-    event UnwrapRequested(address indexed receiver, euint64 amount);
-    event UnwrapFinalized(address indexed receiver, euint64 encryptedAmount, uint64 cleartextAmount);
-
-    error InvalidUnwrapRequest(euint64 amount);
+    error InvalidUnwrapRequest(bytes32 unwrapRequestId);
     error ERC7984TotalSupplyOverflow();
 
     constructor(IERC20 underlying_) {
@@ -49,7 +49,7 @@ abstract contract ERC7984ERC20Wrapper is ERC7984, IERC1363Receiver {
     /**
      * @dev `ERC1363` callback function which wraps tokens to the address specified in `data` or
      * the address `from` (if no address is specified in `data`). This function refunds any excess tokens
-     * sent beyond the nearest multiple of {rate} to `from`. See {wrap} from more details on wrapping tokens.
+     * sent beyond the nearest multiple of {rate} to `from`. See {wrap} for more details on wrapping tokens.
      */
     function onTransferReceived(
         address /*operator*/,
@@ -58,7 +58,7 @@ abstract contract ERC7984ERC20Wrapper is ERC7984, IERC1363Receiver {
         bytes calldata data
     ) public virtual returns (bytes4) {
         // check caller is the token contract
-        require(address(underlying()) == msg.sender, ERC7984UnauthorizedCaller(msg.sender));
+        require(underlying() == msg.sender, ERC7984UnauthorizedCaller(msg.sender));
 
         // mint confidential token
         address to = data.length < 20 ? from : address(bytes20(data));
@@ -66,88 +66,100 @@ abstract contract ERC7984ERC20Wrapper is ERC7984, IERC1363Receiver {
 
         // transfer excess back to the sender
         uint256 excess = amount % rate();
-        if (excess > 0) SafeERC20.safeTransfer(underlying(), from, excess);
+        if (excess > 0) SafeERC20.safeTransfer(IERC20(underlying()), from, excess);
 
         // return magic value
         return IERC1363Receiver.onTransferReceived.selector;
     }
 
     /**
-     * @dev Wraps amount `amount` of the underlying token into a confidential token and sends it to
-     * `to`. Tokens are exchanged at a fixed rate specified by {rate} such that `amount / rate()` confidential
-     * tokens are sent. Amount transferred in is rounded down to the nearest multiple of {rate}.
+     * @dev See {IERC7984ERC20Wrapper-wrap}. Tokens are exchanged at a fixed rate specified by {rate} such that
+     * `amount / rate()` confidential tokens are sent. The amount transferred in is rounded down to the nearest
+     * multiple of {rate}.
+     *
+     * Returns the amount of wrapped token sent.
      */
-    function wrap(address to, uint256 amount) public virtual {
+    function wrap(address to, uint256 amount) public virtual override returns (euint64) {
         // take ownership of the tokens
-        SafeERC20.safeTransferFrom(underlying(), msg.sender, address(this), amount - (amount % rate()));
+        SafeERC20.safeTransferFrom(IERC20(underlying()), msg.sender, address(this), amount - (amount % rate()));
 
         // mint confidential token
-        _mint(to, FHE.asEuint64(SafeCast.toUint64(amount / rate())));
+        euint64 wrappedAmountSent = _mint(to, FHE.asEuint64(SafeCast.toUint64(amount / rate())));
+        FHE.allowTransient(wrappedAmountSent, msg.sender);
+
+        return wrappedAmountSent;
     }
 
-    /**
-     * @dev Unwraps tokens from `from` and sends the underlying tokens to `to`. The caller must be `from`
-     * or be an approved operator for `from`. `amount * rate()` underlying tokens are sent to `to`.
-     *
-     * NOTE: The unwrap request created by this function must be finalized by calling {finalizeUnwrap}.
-     * NOTE: The caller *must* already be approved by ACL for the given `amount`.
-     */
-    function unwrap(address from, address to, euint64 amount) public virtual {
+    /// @dev Unwrap without passing an input proof. See {unwrap-address-address-bytes32-bytes} for more details.
+    function unwrap(address from, address to, euint64 amount) public virtual returns (bytes32) {
         require(FHE.isAllowed(amount, msg.sender), ERC7984UnauthorizedUseOfEncryptedAmount(amount, msg.sender));
-        _unwrap(from, to, amount);
+        return _unwrap(from, to, amount);
     }
 
     /**
-     * @dev Variant of {unwrap} that passes an `inputProof` which approves the caller for the `encryptedAmount`
-     * in the ACL.
+     * @dev See {IERC7984ERC20Wrapper-unwrap}. `amount * rate()` underlying tokens are sent to `to`.
+     *
+     * NOTE: The unwrap request created by this function must be finalized by calling {finalizeUnwrap}.
      */
     function unwrap(
         address from,
         address to,
         externalEuint64 encryptedAmount,
         bytes calldata inputProof
-    ) public virtual {
-        _unwrap(from, to, FHE.fromExternal(encryptedAmount, inputProof));
+    ) public virtual returns (bytes32) {
+        return _unwrap(from, to, FHE.fromExternal(encryptedAmount, inputProof));
     }
 
-    /// @dev Fills an unwrap request for a given cipher-text `burntAmount` with the `cleartextAmount` and `decryptionProof`.
+    /// @inheritdoc IERC7984ERC20Wrapper
     function finalizeUnwrap(
-        euint64 burntAmount,
-        uint64 burntAmountCleartext,
+        bytes32 unwrapRequestId,
+        uint64 unwrapAmountCleartext,
         bytes calldata decryptionProof
     ) public virtual {
-        address to = _unwrapRequests[burntAmount];
-        require(to != address(0), InvalidUnwrapRequest(burntAmount));
-        delete _unwrapRequests[burntAmount];
+        address to = unwrapRequester(unwrapRequestId);
+        require(to != address(0), InvalidUnwrapRequest(unwrapRequestId));
+
+        euint64 unwrapAmount_ = unwrapAmount(unwrapRequestId);
+        delete _unwrapRequests[unwrapRequestId];
 
         bytes32[] memory handles = new bytes32[](1);
-        handles[0] = euint64.unwrap(burntAmount);
+        handles[0] = euint64.unwrap(unwrapAmount_);
 
-        bytes memory cleartexts = abi.encode(burntAmountCleartext);
+        bytes memory cleartexts = abi.encode(unwrapAmountCleartext);
 
         FHE.checkSignatures(handles, cleartexts, decryptionProof);
 
-        SafeERC20.safeTransfer(underlying(), to, burntAmountCleartext * rate());
+        SafeERC20.safeTransfer(IERC20(underlying()), to, unwrapAmountCleartext * rate());
 
-        emit UnwrapFinalized(to, burntAmount, burntAmountCleartext);
+        emit UnwrapFinalized(to, unwrapRequestId, unwrapAmount_, unwrapAmountCleartext);
     }
 
     /// @inheritdoc ERC7984
-    function decimals() public view virtual override returns (uint8) {
+    function decimals() public view virtual override(IERC7984, ERC7984) returns (uint8) {
         return _decimals;
     }
 
-    /**
-     * @dev Returns the rate at which the underlying token is converted to the wrapped token.
-     * For example, if the `rate` is 1000, then 1000 units of the underlying token equal 1 unit of the wrapped token.
-     */
+    /// @inheritdoc IERC7984ERC20Wrapper
     function rate() public view virtual returns (uint256) {
         return _rate;
     }
 
-    /// @dev Returns the address of the underlying ERC-20 token that is being wrapped.
-    function underlying() public view returns (IERC20) {
-        return _underlying;
+    /// @inheritdoc IERC7984ERC20Wrapper
+    function underlying() public view virtual override returns (address) {
+        return address(_underlying);
+    }
+
+    /// @inheritdoc IERC7984ERC20Wrapper
+    function unwrapAmount(bytes32 unwrapRequestId) public view virtual returns (euint64) {
+        return euint64.wrap(unwrapRequestId);
+    }
+
+    /// @inheritdoc IERC165
+    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC7984) returns (bool) {
+        return
+            interfaceId == type(IERC7984ERC20Wrapper).interfaceId ||
+            interfaceId == type(IERC1363Receiver).interfaceId ||
+            super.supportsInterface(interfaceId);
     }
 
     /**
@@ -159,7 +171,7 @@ abstract contract ERC7984ERC20Wrapper is ERC7984, IERC1363Receiver {
      * on {finalizeUnwrap}.
      */
     function inferredTotalSupply() public view virtual returns (uint256) {
-        return underlying().balanceOf(address(this)) / rate();
+        return IERC20(underlying()).balanceOf(address(this)) / rate();
     }
 
     /// @dev Returns the maximum total supply of wrapped tokens supported by the encrypted datatype.
@@ -167,6 +179,14 @@ abstract contract ERC7984ERC20Wrapper is ERC7984, IERC1363Receiver {
         return type(uint64).max;
     }
 
+    /**
+     * @dev Get the address that has a pending unwrap request for the given `unwrapAmount`. Returns `address(0)` if no pending
+     * unwrap request for the amount `unwrapAmount` exists.
+     */
+    function unwrapRequester(bytes32 unwrapRequestId) public view virtual returns (address) {
+        return _unwrapRequests[unwrapRequestId];
+    }
+
     /**
      * @dev This function must revert if the new {confidentialTotalSupply} is invalid (overflow occurred).
      *
@@ -188,19 +208,25 @@ abstract contract ERC7984ERC20Wrapper is ERC7984, IERC1363Receiver {
         return super._update(from, to, amount);
     }
 
-    /// @dev Internal logic for handling the creation of unwrap requests.
-    function _unwrap(address from, address to, euint64 amount) internal virtual {
+    /// @dev Internal logic for handling the creation of unwrap requests. Returns the unwrap request id.
+    function _unwrap(address from, address to, euint64 amount) internal virtual returns (bytes32) {
         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);
-        FHE.makePubliclyDecryptable(burntAmount);
+        euint64 unwrapAmount_ = _burn(from, amount);
+        FHE.makePubliclyDecryptable(unwrapAmount_);
+
+        assert(unwrapRequester(euint64.unwrap(unwrapAmount_)) == address(0));
 
-        assert(_unwrapRequests[burntAmount] == address(0));
-        _unwrapRequests[burntAmount] = to;
+        // WARNING: Directly using the cipher-text as the unwrap request id assumes that
+        // cipher-texts are unique--this holds here but is not always true. Be cautious when assuming
+        // cipher-text uniqueness.
+        bytes32 unwrapRequestId = euint64.unwrap(unwrapAmount_);
+        _unwrapRequests[unwrapRequestId] = to;
 
-        emit UnwrapRequested(to, burntAmount);
+        emit UnwrapRequested(to, unwrapRequestId, unwrapAmount_);
+        return unwrapRequestId;
     }
 
     /**

package/token/ERC7984/extensions/ERC7984Freezable.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.3.0) (token/ERC7984/extensions/ERC7984Freezable.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.4.0-rc.0) (token/ERC7984/extensions/ERC7984Freezable.sol)
 
 pragma solidity ^0.8.27;
 
@@ -9,11 +9,10 @@ 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.
+ * freezing mechanism that can be managed by calling the internal function
+ * {_setConfidentialFrozen} by an inheriting contract.
  *
- * The freezing mechanism provides the guarantee to the contract owner
- * (e.g. a DAO or a well-configured multisig) that a specific confidential
+ * The freezing mechanism provides the guarantee that a specific confidential
  * amount of tokens held by an account won't be transferable until those
  * tokens are unfrozen.
  *

package/token/ERC7984/extensions/ERC7984ObserverAccess.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.3.0) (token/ERC7984/extensions/ERC7984ObserverAccess.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.4.0-rc.0) (token/ERC7984/extensions/ERC7984ObserverAccess.sol)
 
 pragma solidity ^0.8.27;
 
@@ -7,8 +7,8 @@ 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.
+ * @dev Extension of {ERC7984} that allows each account to add an observer who is given
+ * permanent ACL access to its transfer and balance amounts. An observer can be added or removed at any point in time.
  */
 abstract contract ERC7984ObserverAccess is ERC7984 {
     mapping(address account => address) private _observers;

package/token/ERC7984/extensions/ERC7984Restricted.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.3.0) (token/ERC7984/extensions/ERC7984Restricted.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.4.0-rc.0) (token/ERC7984/extensions/ERC7984Restricted.sol)
 
 pragma solidity ^0.8.27;
 
@@ -7,11 +7,11 @@ import {ERC7984, euint64} from "../ERC7984.sol";
 
 /**
  * @dev Extension of {ERC7984} that implements user account transfer restrictions through the
- * {isUserAllowed} function. Inspired by
+ * {canTransact} 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`
+ * By default, each account has no explicit restriction. The {canTransact} function acts as
+ * a blocklist. Developers can override {canTransact} to check that `restriction == ALLOWED`
  * to implement an allowlist.
  */
 abstract contract ERC7984Restricted is ERC7984 {
@@ -39,7 +39,7 @@ abstract contract ERC7984Restricted is ERC7984 {
      *
      * Default implementation only disallows explicitly BLOCKED accounts (i.e. a blocklist).
      */
-    function isUserAllowed(address account) public view virtual returns (bool) {
+    function canTransact(address account) public view virtual returns (bool) {
         return getRestriction(account) != Restriction.BLOCKED; // i.e. DEFAULT && ALLOWED
     }
 
@@ -48,8 +48,8 @@ abstract contract ERC7984Restricted is ERC7984 {
      *
      * Requirements:
      *
-     * * `from` must be allowed to transfer tokens (see {isUserAllowed}).
-     * * `to` must be allowed to receive tokens (see {isUserAllowed}).
+     * * `from` must be allowed to transfer tokens (see {canTransact}).
+     * * `to` must be allowed to receive tokens (see {canTransact}).
      *
      * The default restriction behavior can be changed (for a pass-through for instance) by overriding
      * {_checkSenderRestriction} and/or {_checkRecipientRestriction}.
@@ -85,7 +85,7 @@ abstract contract ERC7984Restricted is ERC7984 {
 
     /// @dev Checks if a user account is restricted. Reverts with {UserRestricted} if so.
     function _checkRestriction(address account) internal view virtual {
-        require(isUserAllowed(account), UserRestricted(account));
+        require(canTransact(account), UserRestricted(account));
     }
 
     /**

package/token/ERC7984/extensions/ERC7984Rwa.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.3.0) (token/ERC7984/extensions/ERC7984Rwa.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.4.0-rc.0) (token/ERC7984/extensions/ERC7984Rwa.sol)
 
 pragma solidity ^0.8.27;
 
@@ -204,10 +204,8 @@ abstract contract ERC7984Rwa is IERC7984Rwa, ERC7984Freezable, ERC7984Restricted
     }
 
     /// @inheritdoc ERC7984Restricted
-    function isUserAllowed(
-        address account
-    ) public view virtual override(IERC7984Rwa, ERC7984Restricted) returns (bool) {
-        return super.isUserAllowed(account);
+    function canTransact(address account) public view virtual override(IERC7984Rwa, ERC7984Restricted) returns (bool) {
+        return super.canTransact(account);
     }
 
     /// @dev Internal function which updates confidential balances while performing frozen and restriction compliance checks.
@@ -242,7 +240,7 @@ abstract contract ERC7984Rwa is IERC7984Rwa, ERC7984Freezable, ERC7984Restricted
     /// @dev Private function which checks if the called function is a {forceConfidentialTransferFrom}.
     function _isForceTransfer() private pure returns (bool) {
         return
-            msg.sig == 0x6c9c3c85 || // bytes4(keccak256("forceConfidentialTransferFrom(address,address,bytes32)"))
-            msg.sig == 0x44fd6e40; // bytes4(keccak256("forceConfidentialTransferFrom(address,address,bytes32,bytes)"))
+            msg.sig == 0x6c9c3c85 || // bytes4(keccak256("forceConfidentialTransferFrom(address,address,bytes32,bytes)"))
+            msg.sig == 0x44fd6e40; // bytes4(keccak256("forceConfidentialTransferFrom(address,address,bytes32)"))
     }
 }

package/token/ERC7984/extensions/ERC7984Votes.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.3.0) (token/ERC7984/extensions/ERC7984Votes.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.4.0-rc.0) (token/ERC7984/extensions/ERC7984Votes.sol)
 pragma solidity ^0.8.27;
 
 import {euint64} from "@fhevm/solidity/lib/FHE.sol";
@@ -10,7 +10,7 @@ import {ERC7984} from "./../ERC7984.sol";
  * @dev Extension of {ERC7984} supporting confidential votes tracking and delegation.
  *
  * The amount of confidential voting units an account has is equal to the balance of
- * that account. Voing power is taken into account when an account delegates votes to itself or to another
+ * that account. Voting power is taken into account when an account delegates votes to itself or to another
  * account.
  */
 abstract contract ERC7984Votes is ERC7984, VotesConfidential {

package/utils/FHESafeMath.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.3.0) (utils/FHESafeMath.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.4.0-rc.0) (utils/FHESafeMath.sol)
 pragma solidity ^0.8.24;
 
 import {FHE, ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
@@ -9,7 +9,7 @@ import {FHE, ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
  * to handle potential overflows in FHE operations.
  *
  * NOTE: An uninitialized `euint64` value (equivalent to euint64.wrap(bytes32(0))) is evaluated as 0.
- * This library will may return an uninitialized value if all inputs are uninitialized.
+ * This library may return an uninitialized value if all inputs are uninitialized.
  */
 library FHESafeMath {
     /**

package/utils/HandleAccessManager.sol

@@ -1,19 +1,20 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (utils/HandleAccessManager.sol)
-pragma solidity ^0.8.24;
+// OpenZeppelin Confidential Contracts (last updated v0.4.0-rc.0) (utils/HandleAccessManager.sol)
+pragma solidity ^0.8.26;
 
 import {Impl} from "@fhevm/solidity/lib/Impl.sol";
 
 abstract contract HandleAccessManager {
+    error HandleAccessManagerNotAllowed(bytes32 handle, address account);
+
     /**
      * @dev Get handle access for the given handle `handle`. Access will be given to the
      * account `account` with the given persistence flag.
      *
-     * NOTE: This function call is gated by `msg.sender` and validated by the
-     * {_validateHandleAllowance} function.
+     * NOTE: This function call is validated by {_validateHandleAllowance}.
      */
     function getHandleAllowance(bytes32 handle, address account, bool persistent) public virtual {
-        _validateHandleAllowance(handle);
+        require(_validateHandleAllowance(handle), HandleAccessManagerNotAllowed(handle, account));
         if (persistent) {
             Impl.allow(handle, account);
         } else {
@@ -22,8 +23,8 @@ abstract contract HandleAccessManager {
     }
 
     /**
-     * @dev Unimplemented function that must revert if the message sender is not allowed to call
+     * @dev Unimplemented function that must return true if the message sender is allowed to call
      * {getHandleAllowance} for the given handle.
      */
-    function _validateHandleAllowance(bytes32 handle) internal view virtual;
+    function _validateHandleAllowance(bytes32 handle) internal view virtual returns (bool);
 }

package/utils/structs/CheckpointsConfidential.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (utils/structs/CheckpointsConfidential.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.4.0-rc.0) (utils/structs/CheckpointsConfidential.sol)
 // This file was procedurally generated from scripts/generate/templates/CheckpointsConfidential.js.
 
 pragma solidity ^0.8.24;
 
 import {euint32, euint64} from "@fhevm/solidity/lib/FHE.sol";
 import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
-import {Checkpoints} from "./temporary-Checkpoints.sol";
+import {Checkpoints} from "@openzeppelin/contracts/utils/structs/Checkpoints.sol";
 
 /**
  * @dev This library defines the `Trace*` struct, for checkpointing values as they change at different points in

package/build/contracts/Checkpoints.json

@@ -1,16 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "Checkpoints",
-  "sourceName": "contracts/utils/structs/temporary-Checkpoints.sol",
-  "abi": [
-    {
-      "inputs": [],
-      "name": "CheckpointUnorderedInsertion",
-      "type": "error"
-    }
-  ],
-  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212207ac2b5a91bbe8d5c2edc50cd6b8ca65dda1c06dc3baad1b46f94f6cc976f083064736f6c634300081d0033",
-  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212207ac2b5a91bbe8d5c2edc50cd6b8ca65dda1c06dc3baad1b46f94f6cc976f083064736f6c634300081d0033",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}