create WithdrawalLogic

0age · 0age · commit efd14f46ff53 · 2024-10-30T22:03:49.000-07:00
diff --git a/src/lib/ClaimProcessorLogic.sol b/src/lib/ClaimProcessorLogic.sol
@@ -56,10 +56,10 @@ import { EfficiencyLib } from "./EfficiencyLib.sol";
 import { FunctionCastLib } from "./FunctionCastLib.sol";
 import { HashLib } from "./HashLib.sol";
 import { IdLib } from "./IdLib.sol";
-import { DepositLogic } from "./DepositLogic.sol";
+import { WithdrawalLogic } from "./WithdrawalLogic.sol";
 import { ValidityLib } from "./ValidityLib.sol";
 
-contract ClaimProcessorLogic is DepositLogic {
+contract ClaimProcessorLogic is WithdrawalLogic {
     using HashLib for address;
     using HashLib for bytes32;
     using HashLib for uint256;
@@ -130,6 +130,9 @@ contract ClaimProcessorLogic is DepositLogic {
     using FunctionCastLib for function(bytes32, bytes32, uint256, uint256, bytes32, function(address, address, uint256, uint256) internal returns (bool)) internal returns (bool);
     using FunctionCastLib for function(bytes32, bytes32, uint256, uint256, bytes32, bytes32, function(address, address, uint256, uint256) internal returns (bool)) internal returns (bool);
 
+    /// @dev `keccak256(bytes("Claim(address,address,address,bytes32)"))`.
+    uint256 private constant _CLAIM_EVENT_SIGNATURE = 0x770c32a2314b700d6239ee35ba23a9690f2fceb93a55d8c753e953059b3b18d4;
+
     function _processSimpleClaim(bytes32 messageHash, uint256 calldataPointer, uint256 offsetToId, bytes32 typehash, function(address, address, uint256, uint256) internal returns (bool) operation)
         internal
         returns (bool)
diff --git a/src/lib/InternalLogic.sol b/src/lib/InternalLogic.sol
@@ -84,6 +84,13 @@ contract InternalLogic is Tstorish {
         _PERMIT2_INITIALLY_DEPLOYED = _checkPermit2Deployment();
     }
 
+    function _emitClaim(address sponsor, bytes32 messageHash, address allocator) internal {
+        assembly ("memory-safe") {
+            mstore(0, messageHash)
+            log4(0, 0x20, _CLAIM_EVENT_SIGNATURE, shr(0x60, shl(0x60, sponsor)), shr(0x60, shl(0x60, allocator)), caller())
+        }
+    }
+
     function _notExpiredAndSignedByAllocator(bytes32 messageHash, address allocator, BasicTransfer calldata transferPayload) internal {
         transferPayload.expires.later();
 
@@ -100,71 +107,6 @@ contract InternalLogic is Tstorish {
         _clearTstorish(_REENTRANCY_GUARD_SLOT);
     }
 
-    function _deriveConsistentAllocatorAndConsumeNonce(TransferComponent[] calldata components, uint256 nonce) internal returns (address allocator) {
-        uint256 totalComponents = components.length;
-
-        uint256 errorBuffer = (totalComponents == 0).asUint256();
-
-        // TODO: bounds checks on these array accesses can be skipped as an optimization
-        uint96 allocatorId = components[0].id.toAllocatorId();
-
-        allocator = allocatorId.fromRegisteredAllocatorIdWithConsumed(nonce);
-
-        unchecked {
-            for (uint256 i = 1; i < totalComponents; ++i) {
-                errorBuffer |= (components[i].id.toAllocatorId() != allocatorId).asUint256();
-            }
-        }
-
-        assembly ("memory-safe") {
-            if errorBuffer {
-                // revert InvalidBatchAllocation()
-                mstore(0, 0x3a03d3bb)
-                revert(0x1c, 0x04)
-            }
-        }
-    }
-
-    function _deriveConsistentAllocatorAndConsumeNonce(SplitByIdComponent[] calldata components, uint256 nonce) internal returns (address allocator) {
-        uint256 totalComponents = components.length;
-
-        uint256 errorBuffer = (totalComponents == 0).asUint256();
-
-        // TODO: bounds checks on these array accesses can be skipped as an optimization
-        uint96 allocatorId = components[0].id.toAllocatorId();
-
-        allocator = allocatorId.fromRegisteredAllocatorIdWithConsumed(nonce);
-
-        unchecked {
-            for (uint256 i = 1; i < totalComponents; ++i) {
-                errorBuffer |= (components[i].id.toAllocatorId() != allocatorId).asUint256();
-            }
-        }
-
-        assembly ("memory-safe") {
-            if errorBuffer {
-                // revert InvalidBatchAllocation()
-                mstore(0, 0x3a03d3bb)
-                revert(0x1c, 0x04)
-            }
-        }
-    }
-
-    function _emitClaim(address sponsor, bytes32 messageHash, address allocator) internal {
-        assembly ("memory-safe") {
-            mstore(0, messageHash)
-            log4(0, 0x20, _CLAIM_EVENT_SIGNATURE, shr(0x60, shl(0x60, sponsor)), shr(0x60, shl(0x60, allocator)), caller())
-        }
-    }
-
-    function _emitForcedWithdrawalStatusUpdatedEvent(uint256 id, uint256 withdrawableAt) internal {
-        assembly ("memory-safe") {
-            mstore(0, iszero(iszero(withdrawableAt)))
-            mstore(0x20, withdrawableAt)
-            log3(0, 0x40, _FORCED_WITHDRAWAL_STATUS_UPDATED_SIGNATURE, caller(), id)
-        }
-    }
-
     function _register(address sponsor, bytes32 claimHash, bytes32 typehash, uint256 duration) internal {
         assembly ("memory-safe") {
             let m := mload(0x40)
@@ -204,56 +146,6 @@ contract InternalLogic is Tstorish {
         return true;
     }
 
-    function _enableForcedWithdrawal(uint256 id) internal returns (uint256 withdrawableAt) {
-        // overflow check not necessary as reset period is capped
-        unchecked {
-            withdrawableAt = block.timestamp + id.toResetPeriod().toSeconds();
-        }
-
-        uint256 cutoffTimeSlotLocation = _getCutoffTimeSlot(msg.sender, id);
-        assembly ("memory-safe") {
-            sstore(cutoffTimeSlotLocation, withdrawableAt)
-        }
-
-        _emitForcedWithdrawalStatusUpdatedEvent(id, withdrawableAt);
-    }
-
-    function _disableForcedWithdrawal(uint256 id) internal returns (bool) {
-        uint256 cutoffTimeSlotLocation = _getCutoffTimeSlot(msg.sender, id);
-
-        assembly ("memory-safe") {
-            if iszero(sload(cutoffTimeSlotLocation)) {
-                // revert ForcedWithdrawalAlreadyDisabled(msg.sender, id)
-                mstore(0, 0xe632dbad)
-                mstore(0x20, caller())
-                mstore(0x40, id)
-                revert(0x1c, 0x44)
-            }
-
-            sstore(cutoffTimeSlotLocation, 0)
-        }
-
-        _emitForcedWithdrawalStatusUpdatedEvent(id, uint256(0).asStubborn());
-
-        return true;
-    }
-
-    function _processForcedWithdrawal(uint256 id, address recipient, uint256 amount) internal returns (bool) {
-        uint256 cutoffTimeSlotLocation = _getCutoffTimeSlot(msg.sender, id);
-
-        assembly ("memory-safe") {
-            let withdrawableAt := sload(cutoffTimeSlotLocation)
-            if or(iszero(withdrawableAt), gt(withdrawableAt, timestamp())) {
-                // revert PrematureWithdrawal(id)
-                mstore(0, 0x9287bcb0)
-                mstore(0x20, id)
-                revert(0x1c, 0x24)
-            }
-        }
-
-        return _withdraw(msg.sender, recipient, id, amount);
-    }
-
     function _consume(uint256[] calldata nonces) internal returns (bool) {
         // NOTE: this may not be necessary, consider removing
         msg.sender.usingAllocatorId().mustHaveARegisteredAllocator();
@@ -292,60 +184,6 @@ contract InternalLogic is Tstorish {
         allocatorId = allocator.register();
     }
 
-    function _getForcedWithdrawalStatus(address account, uint256 id) internal view returns (ForcedWithdrawalStatus status, uint256 forcedWithdrawalAvailableAt) {
-        uint256 cutoffTimeSlotLocation = _getCutoffTimeSlot(account, id);
-        assembly ("memory-safe") {
-            forcedWithdrawalAvailableAt := sload(cutoffTimeSlotLocation)
-            status := mul(iszero(iszero(forcedWithdrawalAvailableAt)), sub(2, gt(forcedWithdrawalAvailableAt, timestamp())))
-        }
-    }
-
-    /// @dev Burns `amount` token `id` from `from` without checking transfer hooks and sends
-    /// the corresponding underlying tokens to `to`. Emits a {Transfer} event.
-    function _withdraw(address from, address to, uint256 id, uint256 amount) internal returns (bool) {
-        _setReentrancyGuard();
-        address token = id.toToken();
-
-        if (token == address(0)) {
-            to.safeTransferETH(amount);
-        } else {
-            uint256 initialBalance = token.balanceOf(address(this));
-            token.safeTransfer(to, amount);
-            // NOTE: if the balance increased, this will underflow to a massive number causing
-            // the burn to fail; furthermore, this scenario would indicate a very broken token
-            unchecked {
-                amount = initialBalance - token.balanceOf(address(this));
-            }
-        }
-
-        assembly ("memory-safe") {
-            // Compute the balance slot.
-            mstore(0x20, _ERC6909_MASTER_SLOT_SEED)
-            mstore(0x14, from)
-            mstore(0x00, id)
-            let fromBalanceSlot := keccak256(0x00, 0x40)
-            let fromBalance := sload(fromBalanceSlot)
-            // Revert if insufficient balance.
-            if gt(amount, fromBalance) {
-                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
-                revert(0x1c, 0x04)
-            }
-            // Subtract and store the updated balance.
-            sstore(fromBalanceSlot, sub(fromBalance, amount))
-
-            let account := shr(0x60, shl(0x60, from))
-
-            // Emit the {Transfer} and {Withdrawal} events.
-            mstore(0x00, caller())
-            mstore(0x20, amount)
-            log4(0x00, 0x40, _TRANSFER_EVENT_SIGNATURE, account, 0, id)
-        }
-
-        _clearReentrancyGuard();
-
-        return true;
-    }
-
     function _getLockDetails(uint256 id) internal view returns (address token, address allocator, ResetPeriod resetPeriod, Scope scope) {
         token = id.toToken();
         allocator = id.toAllocatorId().toRegisteredAllocator();
@@ -400,15 +238,4 @@ contract InternalLogic is Tstorish {
     function _tokenURI(uint256 id) internal view returns (string memory) {
         return _METADATA_RENDERER.uri(id.toLock(), id);
     }
-
-    function _getCutoffTimeSlot(address account, uint256 id) internal pure returns (uint256 cutoffTimeSlotLocation) {
-        assembly ("memory-safe") {
-            let m := mload(0x40)
-            mstore(0x14, account)
-            mstore(0, _FORCED_WITHDRAWAL_ACTIVATIONS_SCOPE)
-            mstore(0x34, id)
-            cutoffTimeSlotLocation := keccak256(0x1c, 0x38)
-            mstore(0x40, m)
-        }
-    }
 }
diff --git a/src/lib/TransferLogic.sol b/src/lib/TransferLogic.sol
@@ -184,4 +184,54 @@ contract TransferLogic is InternalLogic {
             }
         }
     }
+
+    function _deriveConsistentAllocatorAndConsumeNonce(TransferComponent[] calldata components, uint256 nonce) internal returns (address allocator) {
+        uint256 totalComponents = components.length;
+
+        uint256 errorBuffer = (totalComponents == 0).asUint256();
+
+        // TODO: bounds checks on these array accesses can be skipped as an optimization
+        uint96 allocatorId = components[0].id.toAllocatorId();
+
+        allocator = allocatorId.fromRegisteredAllocatorIdWithConsumed(nonce);
+
+        unchecked {
+            for (uint256 i = 1; i < totalComponents; ++i) {
+                errorBuffer |= (components[i].id.toAllocatorId() != allocatorId).asUint256();
+            }
+        }
+
+        assembly ("memory-safe") {
+            if errorBuffer {
+                // revert InvalidBatchAllocation()
+                mstore(0, 0x3a03d3bb)
+                revert(0x1c, 0x04)
+            }
+        }
+    }
+
+    function _deriveConsistentAllocatorAndConsumeNonce(SplitByIdComponent[] calldata components, uint256 nonce) internal returns (address allocator) {
+        uint256 totalComponents = components.length;
+
+        uint256 errorBuffer = (totalComponents == 0).asUint256();
+
+        // TODO: bounds checks on these array accesses can be skipped as an optimization
+        uint96 allocatorId = components[0].id.toAllocatorId();
+
+        allocator = allocatorId.fromRegisteredAllocatorIdWithConsumed(nonce);
+
+        unchecked {
+            for (uint256 i = 1; i < totalComponents; ++i) {
+                errorBuffer |= (components[i].id.toAllocatorId() != allocatorId).asUint256();
+            }
+        }
+
+        assembly ("memory-safe") {
+            if errorBuffer {
+                // revert InvalidBatchAllocation()
+                mstore(0, 0x3a03d3bb)
+                revert(0x1c, 0x04)
+            }
+        }
+    }
 }
diff --git a/src/lib/WithdrawalLogic.sol b/src/lib/WithdrawalLogic.sol
