Remove utils/Counters.sol

CHANGELOG.md

@@ -2,8 +2,9 @@
 
 ### Removals
 
-The following contracts were removed:
+The following contracts and libraries were removed:
 
+- `Counters`
 - `ERC20Snapshot`
 - `ERC20VotesComp`
 - `GovernorVotesComp`

contracts/mocks/proxy/UUPSUpgradeableMock.sol

@@ -3,17 +3,16 @@
 pragma solidity ^0.8.19;
 
 import "../../proxy/utils/UUPSUpgradeable.sol";
-import "../../utils/Counters.sol";
 
 contract NonUpgradeableMock {
-    Counters.Counter internal _counter;
+    uint256 internal _counter;
 
     function current() external view returns (uint256) {
-        return Counters.current(_counter);
+        return _counter;
     }
 
     function increment() external {
-        return Counters.increment(_counter);
+        ++_counter;
     }
 }
 

contracts/utils/Nonces.sol

@@ -1,31 +1,30 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.19;
 
-import "./Counters.sol";
-
 /**
  * @dev Provides tracking nonces for addresses. Nonces will only increment.
  */
 abstract contract Nonces {
-    using Counters for Counters.Counter;
-
-    mapping(address => Counters.Counter) private _nonces;
+    mapping(address => uint256) private _nonces;
 
     /**
      * @dev Returns an address nonce.
      */
     function nonces(address owner) public view virtual returns (uint256) {
-        return _nonces[owner].current();
+        return _nonces[owner];
     }
 
     /**
      * @dev Consumes a nonce.
      *
      * Returns the current value and increments nonce.
      */
-    function _useNonce(address owner) internal virtual returns (uint256 current) {
-        Counters.Counter storage nonce = _nonces[owner];
-        current = nonce.current();
-        nonce.increment();
+    function _useNonce(address owner) internal virtual returns (uint256) {
+        // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be
+        // decremented or reset. This guarantees that the nonce never overflows.
+        unchecked {
+            // It is important to do x++ and not ++x here.
+            return _nonces[owner]++;
+        }
     }
 }

contracts/utils/README.adoc

@@ -10,7 +10,6 @@ The {Address}, {Arrays}, {Base64} and {Strings} libraries provide more operation
 
 For new data types:
 
- * {Counters}: a simple way to get a counter that can only be incremented, decremented or reset. Very useful for ID generation, counting contract activity, among others.
  * {EnumerableMap}: like Solidity's https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`] type, but with key-value _enumeration_: this will let you know how many entries a mapping has, and iterate over them (which is not possible with `mapping`).
  * {EnumerableSet}: like {EnumerableMap}, but for https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets]. Can be used to store privileged accounts, issued IDs, etc.
 
@@ -75,8 +74,6 @@ Ethereum contracts have no native concept of an interface, so applications must
 
 {{Base64}}
 
-{{Counters}}
-
 {{Strings}}
 
 {{ShortStrings}}

docs/modules/ROOT/pages/erc721.adoc

@@ -17,24 +17,21 @@ Here's what a contract for tokenized items might look like:
 pragma solidity ^0.8.19;
 
 import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
-import "@openzeppelin/contracts/utils/Counters.sol";
 
 contract GameItem is ERC721URIStorage {
-    using Counters for Counters.Counter;
-    Counters.Counter private _tokenIds;
+    uint256 private _nextTokenId;
 
     constructor() ERC721("GameItem", "ITM") {}
 
     function awardItem(address player, string memory tokenURI)
         public
         returns (uint256)
     {
-        uint256 newItemId = _tokenIds.current();
-        _mint(player, newItemId);
-        _setTokenURI(newItemId, tokenURI);
+        uint256 tokenId = _nextTokenId++;
+        _mint(player, tokenId);
+        _setTokenURI(tokenId, tokenURI);
 
-        _tokenIds.increment();
-        return newItemId;
+        return tokenId;
     }
 }
 ----

docs/modules/ROOT/pages/utilities.adoc

@@ -97,8 +97,6 @@ If you need support for more powerful collections than Solidity's native arrays
 [[misc]]
 == Misc
 
-Want to keep track of some numbers that increment by 1 every time you want another one? Check out xref:api:utils.adoc#Counters[`Counters`]. This is useful for lots of things, like creating incremental identifiers, as shown on the xref:erc721.adoc[ERC721 guide].
-
 === Base64
 
 xref:api:utils.adoc#Base64[`Base64`] util allows you to transform `bytes32` data into its Base64 `string` representation.

test/utils/Nonces.test.js

@@ -19,7 +19,7 @@ contract('Nonces', function (accounts) {
     expect(await this.nonces.nonces(sender)).to.be.bignumber.equal('0');
 
     const { receipt } = await this.nonces.$_useNonce(sender);
-    expectEvent(receipt, 'return$_useNonce', { current: '0' });
+    expectEvent(receipt, 'return$_useNonce', ['0']);
 
     expect(await this.nonces.nonces(sender)).to.be.bignumber.equal('1');
   });