Rename ReentrancyGuard into TransientLock and ReentrancyGuradBase into ReentrancyGuard

Author: k06a

contracts/libraries/ReentrancyGuard.sol

@@ -2,27 +2,53 @@
 
 pragma solidity ^0.8.0;
 
-import { TransientLib, tuint256 } from "./Transient.sol";
-
-struct ReentrancyGuard {
-    tuint256 _raw;
-}
-
-library ReentrancyGuardLib {
-    using TransientLib for tuint256;
+import { TransientLock, TransientLockLib } from "./TransientLock.sol";
+
+/// @dev Base contract with reentrancy guard functionality using transient storage locks.
+///
+/// Use private _lock defined in this contract:
+/// ```solidity
+/// function swap(...) external nonReentrant {
+/// function doMagic(...) external onlyNonReentrantCall {
+/// ```
+///
+/// Or use your own locks for more granular control:
+/// ```solidity
+/// TransientLock private _myLock;
+/// function swap(...) external nonReentrantLock(_myLock) {
+/// function doMagic(...) external onlyNonReentrantCallLock(_myLock) {
+/// ```
+///
+abstract contract ReentrancyGuard {
+    using TransientLockLib for TransientLock;
+
+    error MissingNonReentrantModifier();
+
+    TransientLock private _lock;
+
+    modifier nonReentrant {
+        _lock.lock();
+        _;
+        _lock.unlock();
+    }
 
-    error ReentrantCallDetected();
-    error EnterLeaveDisbalance();
+    modifier onlyNonReentrantCall {
+        if (!_inNonReentrantCall()) revert MissingNonReentrantModifier();
+        _;
+    }
 
-    function enter(ReentrancyGuard storage self) internal {
-        if (self._raw.inc() != 1) revert ReentrantCallDetected();
+    modifier nonReentrantLock(TransientLock storage lock) {
+        lock.lock();
+        _;
+        lock.unlock();
     }
 
-    function enterNoIncrement(ReentrancyGuard storage self) internal view {
-        if (self._raw.tload() != 0) revert ReentrantCallDetected();
+    modifier onlyNonReentrantCallLock(TransientLock storage lock) {
+        if (!lock.isLocked()) revert MissingNonReentrantModifier();
+        _;
     }
 
-    function leave(ReentrancyGuard storage self) internal {
-        self._raw.dec(EnterLeaveDisbalance.selector);
+    function _inNonReentrantCall() internal view returns (bool) {
+        return _lock.isLocked();
     }
 }

contracts/libraries/ReentrancyGuardBase.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import { TransientLib, tuint256 } from "./Transient.sol";
+
+struct TransientLock {
+    tuint256 _raw;
+}
+
+library TransientLockLib {
+    using TransientLib for tuint256;
+
+    uint256 constant private _UNLOCKED = 0;
+    uint256 constant private _LOCKED = 1;
+
+    error UnexpectedLock();
+    error UnexpectedUnlock();
+
+    function lock(TransientLock storage self) internal {
+        if (self._raw.inc() != _LOCKED) revert UnexpectedLock();
+    }
+
+    function isLocked(TransientLock storage self) internal view returns (bool) {
+        return self._raw.tload() == _LOCKED;
+    }
+
+    function unlock(TransientLock storage self) internal {
+        self._raw.dec(UnexpectedUnlock.selector);
+    }
+
+    function unlock(TransientLock storage self, bytes4 exception) internal {
+        self._raw.dec(exception);
+    }
+}