Feat/caveat test rebase

src/LoanManager.sol

@@ -42,12 +42,13 @@ import {SignatureCheckerLib} from "solady/src/utils/SignatureCheckerLib.sol";
 import {CaveatEnforcer} from "starport-core/enforcers/CaveatEnforcer.sol";
 import {Ownable} from "solady/src/auth/Ownable.sol";
 import {SafeTransferLib} from "solady/src/utils/SafeTransferLib.sol";
+import {PausableNonReentrant} from "starport-core/lib/PausableNonReentrant.sol";
 
 interface LoanSettledCallback {
     function onLoanSettled(LoanManager.Loan calldata loan) external;
 }
 
-contract LoanManager is Ownable, ERC721 {
+contract LoanManager is ERC721, PausableNonReentrant {
     using FixedPointMathLib for uint256;
 
     using {StarPortLib.toReceivedItems} for SpentItem[];
@@ -69,7 +70,6 @@ contract LoanManager is Ownable, ERC721 {
     bytes32 public constant INTENT_ORIGINATION_TYPEHASH =
         keccak256("Origination(bytes32 hash,bytes32 salt,bytes32 caveatHash");
     bytes32 public constant VERSION = keccak256("0");
-    bool public paused;
     address public feeTo;
     uint88 public defaultFeeRake;
     mapping(address => mapping(bytes32 => bool)) public invalidHashes;
@@ -118,8 +118,6 @@ contract LoanManager is Ownable, ERC721 {
 
     event Close(uint256 loanId);
     event Open(uint256 loanId, LoanManager.Loan loan);
-    event Paused();
-    event UnPaused();
 
     error InvalidRefinance();
     error InvalidCustodian();
@@ -138,7 +136,6 @@ contract LoanManager is Ownable, ERC721 {
     error UnauthorizedAdditionalTransferIncluded();
     error InvalidCaveatSigner();
     error MalformedRefinance();
-    error IsPaused();
 
     constructor(ConsiderationInterface seaport_) {
         address custodian = address(new Custodian(this, seaport_));
@@ -188,34 +185,21 @@ contract LoanManager is Ownable, ERC721 {
         revert CannotTransferLoans();
     }
 
-    function pause() external onlyOwner {
-        paused = true;
-        emit Paused();
-    }
-
-    function unPause() external onlyOwner {
-        paused = false;
-        emit UnPaused();
-    }
-
     function originate(
         AdditionalTransfer[] calldata additionalTransfers,
         CaveatEnforcer.CaveatWithApproval calldata borrowerCaveat,
         CaveatEnforcer.CaveatWithApproval calldata lenderCaveat,
         LoanManager.Loan memory loan
-    ) external payable {
-        if (paused) {
-            revert IsPaused();
-        }
+    ) external payable pausableNonReentrant {
         //cache the addresses
         address borrower = loan.borrower;
         address issuer = loan.issuer;
         address feeRecipient = feeTo;
-        if (msg.sender != loan.borrower && !(approvals[borrower][msg.sender] == ApprovalType.BORROWER)) {
+        if (msg.sender != borrower && approvals[borrower][msg.sender] != ApprovalType.BORROWER) {
             _validateAndEnforceCaveats(borrowerCaveat, borrower, additionalTransfers, loan);
         }
 
-        if (msg.sender != issuer && !(approvals[issuer][msg.sender] == ApprovalType.LENDER)) {
+        if (msg.sender != issuer && approvals[issuer][msg.sender] != ApprovalType.LENDER) {
             _validateAndEnforceCaveats(lenderCaveat, issuer, additionalTransfers, loan);
         }
 
@@ -246,10 +230,7 @@ contract LoanManager is Ownable, ERC721 {
         CaveatEnforcer.CaveatWithApproval calldata lenderCaveat,
         LoanManager.Loan memory loan,
         bytes calldata pricingData
-    ) external {
-        if (paused) {
-            revert IsPaused();
-        }
+    ) external pausableNonReentrant {
         (
             SpentItem[] memory considerationPayment,
             SpentItem[] memory carryPayment,
@@ -260,18 +241,21 @@ contract LoanManager is Ownable, ERC721 {
         loan = applyRefinanceConsiderationToLoan(loan, considerationPayment, carryPayment, pricingData);
 
         _transferSpentItems(considerationPayment, lender, loan.issuer);
-        _transferSpentItems(carryPayment, lender, loan.originator);
+
+        if (carryPayment.length > 0) {
+            _transferSpentItems(carryPayment, lender, loan.originator);
+        }
 
         loan.issuer = lender;
         loan.originator = address(0);
         loan.start = 0;
 
-        if (msg.sender != loan.issuer && !(approvals[loan.issuer][msg.sender] == ApprovalType.LENDER)) {
-            _validateAndEnforceCaveats(lenderCaveat, loan.issuer, additionalTransfers, loan);
+        if (msg.sender != lender && approvals[lender][msg.sender] != ApprovalType.LENDER) {
+            _validateAndEnforceCaveats(lenderCaveat, lender, additionalTransfers, loan);
         }
 
         if (additionalTransfers.length > 0) {
-            _validateAdditionalTransfers(loan.borrower, loan.issuer, msg.sender, additionalTransfers);
+            _validateAdditionalTransfers(loan.borrower, lender, msg.sender, additionalTransfers);
             StarPortLib.transferAdditionalTransfers(additionalTransfers);
         }
 
@@ -469,6 +453,14 @@ contract LoanManager is Ownable, ERC721 {
         );
     }
 
+    function incrementCaveatNonce() external {
+        ++caveatNonces[msg.sender];
+    }
+
+    function invalidateCaveatSalt(bytes32 salt) external {
+        invalidHashes[msg.sender][salt] = true;
+    }
+
     /**
      * @dev the erc721 name of the contract
      * @return                   The name of the contract as a string

src/lib/PausableNonReentrant.sol

@@ -0,0 +1,67 @@
+import {Ownable} from "solady/src/auth/Ownable.sol";
+
+abstract contract PausableNonReentrant is Ownable {
+    uint256 private constant _UNLOCKED = 0x1;
+    uint256 private constant _LOCKED = 0x2;
+    uint256 private constant _PAUSED = 0x3;
+
+    uint256 private _state = _UNLOCKED;
+
+    event Paused();
+    event Unpaused();
+
+    error IsPaused();
+    error IsLocked();
+    error NotPaused();
+
+    modifier pausableNonReentrant() {
+        assembly {
+            //If locked or paused, handle revert cases
+            if gt(sload(_state.slot), _UNLOCKED) {
+                if gt(sload(_state.slot), _LOCKED) {
+                    //Revert IsPaused
+                    mstore(0, 0x1309a563)
+                    revert(0x1c, 0x04)
+                }
+                //Revert IsLocked
+                mstore(0, 0xcaa30f55)
+                revert(0x1c, 0x04)
+            }
+            sstore(_state.slot, _LOCKED)
+        }
+        _;
+        assembly {
+            sstore(_state.slot, _UNLOCKED)
+        }
+    }
+
+    function pause() external onlyOwner {
+        assembly {
+            //If locked, prevent owner from overriding state
+            if eq(sload(_state.slot), _LOCKED) {
+                //Revert IsLocked
+                mstore(0, 0xcaa30f55)
+                revert(0x1c, 0x04)
+            }
+            sstore(_state.slot, _PAUSED)
+        }
+        emit Paused();
+    }
+
+    function unpause() external onlyOwner {
+        assembly {
+            //If not paused, prevent owner from overriding state
+            if lt(sload(_state.slot), _PAUSED) {
+                //Revert NotPaused
+                mstore(0, 0x6cd60201)
+                revert(0x1c, 0x04)
+            }
+            sstore(_state.slot, _UNLOCKED)
+        }
+        emit Unpaused();
+    }
+
+    function paused() external view returns (bool) {
+        return _state == _PAUSED;
+    }
+}

test/StarPortTest.sol

@@ -435,6 +435,21 @@ contract StarPortTest is BaseOrderTest {
         }
     }
 
+    function getBorrowerSignedCaveat(
+        BorrowerEnforcer.Details memory details,
+        Account memory signer,
+        bytes32 salt,
+        address enforcer
+    ) public view returns (CaveatEnforcer.CaveatWithApproval memory caveatApproval) {
+        caveatApproval.caveat = new CaveatEnforcer.Caveat[](1);
+        caveatApproval.salt = salt;
+        caveatApproval.caveat[0] =
+            CaveatEnforcer.Caveat({enforcer: enforcer, deadline: block.timestamp + 1 days, data: abi.encode(details)});
+        bytes32 hash = LM.hashCaveatWithSaltAndNonce(signer.addr, salt, caveatApproval.caveat);
+
+        (caveatApproval.v, caveatApproval.r, caveatApproval.s) = vm.sign(signer.key, hash);
+    }
+
     function getLenderSignedCaveat(
         LenderEnforcer.Details memory details,
         Account memory signer,
@@ -498,7 +513,7 @@ contract StarPortTest is BaseOrderTest {
     }
 
     function getRefinanceCaveat(LoanManager.Loan memory loan, bytes memory pricingData, address fulfiller)
-        external
+        public
         returns (LoanManager.Loan memory)
     {
         (SpentItem[] memory considerationPayment, SpentItem[] memory carryPayment,) =